home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.4d7 source / tn3270 / dialogs.c < prev    next >
Text File  |  1992-04-17  |  65KB  |  2,822 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.4d7  April, 1992
  5.  *  Copyright (c) 1988, 1989, 1990, 1991, 1992 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistants Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #pragma segment 3270seg3
  34.  
  35. #if !defined(USEDUMP)
  36.     #include "maclib.h"
  37.     #include "termdef.h"
  38.     #include "tn3270funcs.h"
  39.     #include "globals.h"
  40. #else
  41.     #pragma load "tn3270DumpFile"
  42. #endif
  43.  
  44. #include <Lists.h>
  45.  
  46. #define kButtonFrameSize    3    /* button frame's pen size */
  47. #define kButtonFrameInset  -4    /* inset rectangle adjustment around button */
  48.  
  49. extern char showstg;
  50. extern char notifyavail;
  51. extern nmrmessage *myNMR[NMRNUM];
  52. extern struct Point sfgpoint;
  53. unsigned char * dlgmapptr;
  54. short attnmousepf;                /* for attndlg */
  55.  
  56. extern unsigned char setmsg1[];    
  57. extern unsigned char setmsg2[];
  58. extern unsigned char setmsg3[];
  59.  
  60. static short fmtmaxrows, fmtmaxcols;
  61.  
  62. void aboutdlg(void)
  63. {
  64. DialogPtr dlgptr;
  65. DialogPeek dStorage;
  66. WindowPtr behind;
  67. pascal Boolean (*filterProc) ();
  68. short * itemHitPtr;
  69. short itemHit;
  70. Handle version;
  71. short gtype;
  72. Handle gitem;
  73. Rect gbox;
  74. static unsigned short * DlgFont = (unsigned short *)0xAFA;
  75.  
  76. version = GetResource('GFTM', 0);
  77. dStorage = 0;
  78. behind = (WindowPtr)-1;
  79. *DlgFont = 1;
  80. dlgptr = GetNewDialog(256, dStorage, behind);
  81. ctrwindow(dlgptr);
  82. GetDItem(dlgptr, 3, >ype, &gitem, &gbox);
  83. SetIText(gitem, *version);
  84. arrowcursor();
  85. ShowWindow(dlgptr);
  86.  
  87. /* frame the default selection */
  88. framedflt(dlgptr);
  89.  
  90. filterProc = DlgFilter;
  91. itemHitPtr = &itemHit;
  92. ModalDialog(filterProc, itemHitPtr);
  93. if (itemHit == 2) showstg = 1;
  94. DisposDialog(dlgptr);
  95. *DlgFont = 0;
  96. }
  97.  
  98. void stginfo(cnr *cp)        /* display storage info. */
  99. {
  100. DialogPtr dlgptr;
  101. DialogPeek dStorage;
  102. WindowPtr behind;
  103. pascal Boolean (*filterProc) ();
  104. short * itemHitPtr;
  105. short itemHit;
  106. short gtype;
  107. Handle gitem;
  108. Rect gbox, r;
  109. unsigned char msg[120];
  110. GDHandle currGD;
  111. PixMapHandle currPM;
  112. short i, j;
  113. long l;
  114.  
  115. dStorage = 0;
  116. behind = (WindowPtr)-1;
  117. dlgptr = GetNewDialog(270, dStorage, behind);
  118. ctrwindow(dlgptr);
  119.  
  120. /* define info. text */
  121. if (cp != 0) {
  122.     if (cp->myWindow != 0) {
  123.         if (colormac && (!cp->cs.nocolor)) {
  124.             GetGlobalRect(cp->myWindow, &r);
  125.             currGD = myGetMaxDevice(&r);
  126.             currPM = (*currGD)->gdPMap;
  127.             i = (*currPM)->pixelSize;
  128.             j = 2 << (i-1);
  129.             sprintf(msg, "pixel depth = %d (%d colors)", i, j);
  130.             }
  131.         else {
  132.             sprintf(msg, "pixel depth = 1 (black & white)");
  133.             }
  134.         }
  135.     }
  136. else {
  137.     if (colormac && (!cf_nocolor)) {
  138.         currGD = GetMainDevice();
  139.         currPM = (*currGD)->gdPMap;
  140.         i = (*currPM)->pixelSize;
  141.         j = 2 << (i-1);
  142.         sprintf(msg, "pixel depth = %d (%d colors)", i, j);
  143.         }
  144.     else {
  145.         sprintf(msg, "pixel depth = 1 (black & white)");
  146.         }
  147.     }
  148. GetDItem(dlgptr, 2, >ype, &gitem, &gbox);
  149. c2pstr(msg);
  150. SetIText(gitem, msg);
  151.  
  152. if (cp != 0) {
  153.     if (cp->myWindow != 0) {
  154.         i = (cp->textsize+1023) >> 10;
  155.         if (cp->mapptr == 0) {
  156.             sprintf(msg, "no text bitmap (needs %dK)", i); 
  157.             i = 0;
  158.             }
  159.         else {
  160.             sprintf(msg, "text bitmap = %dK", i);
  161.             }
  162.         }
  163.     }
  164. else {
  165.     i = 0;
  166.     sprintf(msg, "no text bitmap (no session)");
  167.     }
  168. GetDItem(dlgptr, 3, >ype, &gitem, &gbox);
  169. c2pstr(msg);
  170. SetIText(gitem, msg);
  171.  
  172. if (cp != 0) {
  173.     if (cp->myWindow != 0) {
  174.         j = (cp->pictsize+1023) >> 10;
  175.         if (cp->pmapptr == 0) {
  176.             if (j == 0) {
  177.                 sprintf(msg, "no graphics bitmap (disabled)");
  178.                 }
  179.             else {
  180.                 sprintf(msg, "no graphics bitmap (needs %dK)", j);
  181.                 j = 0;
  182.                 }
  183.             }
  184.         else {
  185.             sprintf(msg, "graphics bitmap = %dK", j);
  186.             }
  187.         }
  188.     }
  189. else {
  190.     j = 0;
  191.     sprintf(msg, "no graphics bitmap (no session)");
  192.     }
  193. GetDItem(dlgptr, 4, >ype, &gitem, &gbox);
  194. c2pstr(msg);
  195. SetIText(gitem, msg);
  196.  
  197. sprintf(msg, "bitmap total = %dK", i+j);
  198. GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  199. c2pstr(msg);
  200. SetIText(gitem, msg);
  201.  
  202. MaxApplZone();
  203. l = FreeMem() >> 10;
  204. sprintf(msg, "available storage = %ldK", l);
  205. GetDItem(dlgptr, 6, >ype, &gitem, &gbox);
  206. c2pstr(msg);
  207. SetIText(gitem, msg);
  208. arrowcursor();
  209. ShowWindow(dlgptr);
  210.  
  211. /* frame the default selection */
  212. framedflt(dlgptr);
  213.  
  214. /* show the text */
  215. filterProc = DlgFilter;
  216. itemHitPtr = &itemHit;
  217. ModalDialog(filterProc, itemHitPtr);
  218. DisposDialog(dlgptr);
  219. }
  220.  
  221. void attrdlg(cnr *cp)
  222. {
  223. DialogPtr dlgptr;
  224. DialogPeek dStorage;
  225. WindowPtr behind;
  226. pascal Boolean (*filterProc) ();
  227. short itemHit;
  228. short gtype;
  229. Handle gitem;
  230. Rect gbox;
  231. unsigned char tempmap[35];
  232. register short i, j;
  233. register unsigned char c;
  234.  
  235. dStorage = 0;
  236. behind = (WindowPtr)-1;
  237. dlgptr = GetNewDialog(257, dStorage, behind);
  238. ctrwindow(dlgptr);
  239.  
  240. /* handle attribute selection dialog */
  241. filterProc = DlgFilter;
  242. j = 0;
  243. for (i=0; i<7; i++) {
  244.     c = cp->cs.attrmap[i] >> 3;
  245.     tempmap[j++] = (c & 0x10) >> 4;
  246.     tempmap[j++] = (c & 0x08) >> 3;
  247.     tempmap[j++] = (c & 0x04) >> 2;
  248.     tempmap[j++] = (c & 0x02) >> 1;
  249.     tempmap[j++] = c & 0x01;
  250.     }
  251. for (i=0; i < 35; i++) {
  252.     GetDItem(dlgptr, i+18, >ype, &gitem, &gbox);
  253.     SetCtlValue((ControlHandle)gitem, tempmap[i]);
  254.     }
  255. arrowcursor();
  256. ShowWindow(dlgptr);
  257.  
  258. /* frame the default selection */
  259. framedflt(dlgptr);
  260.  
  261. ModalDialog(filterProc, &itemHit);
  262. while ((itemHit != 1) && (itemHit != 3)) {
  263.     if (itemHit == 2) {        /* set defaults */
  264.         j = 0;
  265.         for (i=0; i<7; i++) {
  266.             c = ds.attrmap[i] >> 3;
  267.             tempmap[j++] = (c & 0x10) >> 4;
  268.             tempmap[j++] = (c & 0x08) >> 3;
  269.             tempmap[j++] = (c & 0x04) >> 2;
  270.             tempmap[j++] = (c & 0x02) >> 1;
  271.             tempmap[j++] = c & 0x01;
  272.             }
  273.         for (i=0; i < 35; i++) {
  274.             GetDItem(dlgptr, i+18, >ype, &gitem, &gbox);
  275.             SetCtlValue((ControlHandle)gitem, tempmap[i]);
  276.             }
  277.         }
  278.     else {
  279.         i = itemHit - 18;
  280.         tempmap[i] ^= 1;
  281.         GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  282.         SetCtlValue((ControlHandle)gitem, tempmap[i]);
  283.         }
  284.     ModalDialog(filterProc, &itemHit);
  285.     }
  286.  
  287. if (itemHit == 1) {
  288.     j = 0;
  289.     for (i=0; i<7; i++) {
  290.         c = (tempmap[j]<<4) + (tempmap[j+1]<<3) + (tempmap[j+2]<<2) +
  291.             (tempmap[j+3]<<1) + tempmap[j+4];
  292.         j += 5;
  293.         c <<= 3;
  294.         cp->cs.attrmap[i] = c;
  295.         }
  296.     if (cp->myWindow != 0) invldscr(cp);
  297.     }
  298.  
  299. /* dispose of dialog and return */
  300. DisposDialog(dlgptr);
  301. }
  302.  
  303. void hostcfdlg(void)
  304. {
  305. DialogPtr dlgptr;
  306. DialogPeek dStorage;
  307. WindowPtr behind;
  308. pascal Boolean (*filterProc) ();
  309. short itemHit;
  310. short gtype;
  311. Handle gitem;
  312. Rect gbox;
  313. unsigned char dflthostname[256];
  314. char savedefault;
  315. short i;
  316.  
  317. dStorage = 0;
  318. behind = (WindowPtr)-1;
  319. dlgptr = GetNewDialog(262, dStorage, behind);
  320. ctrwindow(dlgptr);
  321.  
  322. savedefault = 0;
  323.  
  324. /* show current values of items */
  325. sethostcf(dlgptr, cf_hostname, cf_wtitle, savedefault);
  326.  
  327. /* select host name text */
  328. SelIText(dlgptr, 5, 0, 32767);
  329.  
  330. /* Make Default is only for TCP */
  331. setactive(8, dlgptr, cf_setsflg == 2);
  332.  
  333. arrowcursor();
  334. ShowWindow(dlgptr);
  335.  
  336. /* frame the default selection */
  337. framedflt(dlgptr);
  338.  
  339. /* loop to process changes */
  340.  
  341. filterProc = DlgFilter;
  342. while (true) {
  343.     ModalDialog(filterProc, &itemHit);
  344.     switch(itemHit) {
  345.         case 1:                                    /* OK */
  346.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  347.                 GetIText(gitem, cf_hostname);
  348.                 p2cstr(cf_hostname);
  349.                 GetDItem(dlgptr, 7, >ype, &gitem, &gbox);
  350.                 GetIText(gitem, cf_wtitle);
  351.                 p2cstr(cf_wtitle);
  352.                 break;
  353.         case 2:                                    /* set defaults */
  354.                 if (cf_setsflg == 2) tcpdflthost(dflthostname);
  355.                 else if (cf_setsflg == 1) serdflthost(dflthostname);
  356.                 else sadflthost(dflthostname);
  357.                 savedefault = 0;
  358.                 sethostcf(dlgptr, dflthostname, "", savedefault);
  359.                 i = strlen(dflthostname);
  360.                 SelIText(dlgptr, 5, i, i);
  361.                 break;
  362.         case 8:
  363.                 savedefault ^= 1;
  364.                 sethostcf(dlgptr, 0, 0, savedefault);
  365.                 break;
  366.         default:
  367.                 break;
  368.         }
  369.     if ((itemHit == 1) || (itemHit == 3)) break;
  370.     }
  371.  
  372. if ((itemHit == 1) && savedefault) {    /* store new default host name */
  373.     updhostrsc(cf_hostname);
  374.     }
  375.  
  376. /* dispose of dialog and return */
  377. DisposDialog(dlgptr);
  378. }
  379.  
  380. void sethostcf(DialogPtr dlgptr, unsigned char *hname,
  381.                unsigned char *wtitle, char sdefault)
  382. {
  383. short gtype;
  384. Handle gitem;
  385. Rect gbox;
  386.  
  387. if (hname != 0) {
  388.     GetDItem(dlgptr, 5, >ype, &gitem, &gbox);        /* hostname */
  389.     c2pstr(hname);
  390.     SetIText(gitem, hname);
  391.     p2cstr(hname);
  392.     }
  393.  
  394. if (wtitle != 0) {
  395.     GetDItem(dlgptr, 7, >ype, &gitem, &gbox);        /* window title */
  396.     c2pstr(wtitle);
  397.     SetIText(gitem, wtitle);
  398.     p2cstr(wtitle);
  399.     }
  400.  
  401. GetDItem(dlgptr, 8, >ype, &gitem, &gbox);        /* save default */
  402. SetCtlValue((ControlHandle)gitem, sdefault);
  403. }
  404.  
  405. void specdlg(void)
  406. {
  407. DialogPtr dlgptr;
  408. DialogPeek dStorage;
  409. WindowPtr behind;
  410. pascal Boolean (*filterProc) ();
  411. short * itemHitPtr;
  412. short itemHit, oldHit;
  413. short gtype;
  414. Handle gitem;
  415. Rect gbox;
  416. unsigned char s[256];
  417. unsigned char d_hostname[256];
  418. char d_setsflg, d_dblevel;
  419. unsigned char d_timeout, d_retries;
  420. short i;
  421. int r;
  422.  
  423. dStorage = 0;
  424. behind = (WindowPtr)-1;
  425. dlgptr = GetNewDialog(258, dStorage, behind);
  426. ctrwindow(dlgptr);
  427.  
  428. /* copy current values of items */
  429. memcpy(d_hostname, cf_hostname, 256);
  430. d_setsflg = cf_setsflg;
  431. d_dblevel = cf_dblevel;
  432. d_timeout = cf_timeout;
  433. d_retries = cf_retries;
  434.  
  435. /* show current values of items */
  436. setspec(dlgptr, d_hostname, d_setsflg, d_timeout, d_retries,
  437.         d_dblevel);
  438. /* select host name text */
  439. SelIText(dlgptr, 5, 0, 32767);
  440.  
  441. arrowcursor();
  442. ShowWindow(dlgptr);
  443.  
  444. /* frame the default selection */
  445. framedflt(dlgptr);
  446.  
  447. /* loop to process changes */
  448.  
  449. filterProc = DlgFilter;
  450. itemHitPtr = &itemHit;
  451. oldHit = 0;
  452. while (1) {
  453.     ModalDialog(filterProc, itemHitPtr);
  454.     if ((oldHit > 0) && (oldHit != itemHit))
  455.         switch(oldHit) {
  456.         case 5:                                    /* hostname */
  457.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  458.                 GetIText(gitem, s);
  459.                 p2cstr(s);
  460.                 if (d_setsflg == 2) {
  461.                     if (strlen(s) > 255) s[255] = 0;
  462.                     }
  463.                 else if (strlen(s) > 31) s[31] = 0;
  464.                 i = 0;
  465.                 while (s[i] != 0) {
  466.                     d_hostname[i] = s[i];
  467.                     i++;
  468.                     }
  469.                 d_hostname[i] = 0;
  470.                 c2pstr(d_hostname);
  471.                 SetIText(gitem, d_hostname);
  472.                 p2cstr(d_hostname);
  473.                 break;
  474.         case 11:                                /* timeout   */
  475.         case 13:                                /* retries   */
  476.         case 15:                                /* debug level */
  477.                 GetDItem(dlgptr, oldHit, >ype, &gitem, &gbox);
  478.                 GetIText(gitem, s);
  479.                 p2cstr(s);
  480.                 if (sscanf(s, "%d", &r) != 1) r = 0;
  481.                 if (oldHit == 11) {
  482.                     if ((r > 0) && (r <= 10)) d_timeout = r;
  483.                     sprintf(s, "%2d", d_timeout);
  484.                     }
  485.                 else if (oldHit == 13) {
  486.                     if ((r > 0) && (r <= 99)) d_retries = r;
  487.                     sprintf(s, "%2d", d_retries);
  488.                     }
  489.                 else {
  490.                     if ((r >= 0) && (r <= 127)) d_dblevel = r;
  491.                     sprintf(s, "%2d", d_dblevel);
  492.                     }
  493.                 c2pstr(s);
  494.                 SetIText(gitem, s);
  495.                 break;
  496.         default:
  497.                 break;
  498.         }
  499.     oldHit = itemHit;
  500.     switch(itemHit) {
  501.         case 1:                                    /* OK */
  502.                 memcpy(cf_hostname, d_hostname, 256);
  503.                 cf_setsflg = d_setsflg;
  504.                 cf_dblevel = d_dblevel;        /* copy new settings */
  505.                 cf_timeout = d_timeout;
  506.                 cf_retries = d_retries;
  507.                 break;
  508.         case 2:                                    /* set defaults */
  509.                 d_setsflg = ds.setsflg;
  510.                 if (d_setsflg == 2) tcpdflthost(d_hostname);
  511.                 else if (d_setsflg == 1) serdflthost(d_hostname);
  512.                 else sadflthost(d_hostname);
  513.                 d_dblevel = ds.dblevel;
  514.                 d_timeout = ds.timeout;
  515.                 d_retries = ds.retries;
  516.                 setspec(dlgptr, d_hostname, d_setsflg,
  517.                         d_timeout, d_retries, d_dblevel);
  518.                 i = strlen(d_hostname);
  519.                 SelIText(dlgptr, 5, i, i);
  520.                 break;
  521.         case 6:                    /* Make Default for host name */
  522.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  523.                 GetIText(gitem, s);
  524.                 p2cstr(s);
  525.                 updhostrsc(s);
  526.                 break;
  527.         case 7:                                    /* AppleTalk */
  528.         case 8:                                    /* Serial    */
  529.         case 9:                                    /* TCP/IP     */
  530.                 d_setsflg = itemHit - 7;
  531.                 GetDItem(dlgptr, 7, >ype, &gitem, &gbox);
  532.                 SetCtlValue((ControlHandle)gitem, d_setsflg == 0);
  533.                 GetDItem(dlgptr, 8, >ype, &gitem, &gbox);
  534.                 SetCtlValue((ControlHandle)gitem, d_setsflg  == 1);
  535.                 GetDItem(dlgptr, 9, >ype, &gitem, &gbox);
  536.                 SetCtlValue((ControlHandle)gitem, d_setsflg  == 2);
  537.                 break;
  538.         default: break;
  539.         }
  540.     if ((itemHit == 1) || (itemHit == 3)) break;
  541.     }
  542.  
  543. /* dispose of dialog and return */
  544. DisposDialog(dlgptr);
  545. }
  546.  
  547. void setspec(DialogPtr dlgptr, unsigned char *hname, char sflg,
  548.              unsigned char timeout, unsigned char retries,
  549.              char debug)
  550. {
  551. short gtype;
  552. Handle gitem;
  553. Rect gbox;
  554. unsigned char s[40];
  555.  
  556. GetDItem(dlgptr, 5, >ype, &gitem, &gbox);        /* hostname */
  557. c2pstr(hname);
  558. SetIText(gitem, hname);
  559. p2cstr(hname);
  560.  
  561. GetDItem(dlgptr, 7, >ype, &gitem, &gbox);        /* Standalone */
  562. SetCtlValue((ControlHandle)gitem, sflg == 0);
  563.  
  564. GetDItem(dlgptr, 8, >ype, &gitem, &gbox);        /* Serial */
  565. SetCtlValue((ControlHandle)gitem, sflg  == 1);
  566.  
  567. GetDItem(dlgptr, 9, >ype, &gitem, &gbox);        /* TCP/IP */
  568. SetCtlValue((ControlHandle)gitem, sflg  == 2);
  569.  
  570. GetDItem(dlgptr, 11, >ype, &gitem, &gbox);    /* timeout */
  571. sprintf(s, "%2d", timeout);
  572. c2pstr(s);
  573. SetIText(gitem, s);
  574.  
  575. GetDItem(dlgptr, 13, >ype, &gitem, &gbox);    /* retries */
  576. sprintf(s, "%2d", retries);
  577. c2pstr(s);
  578. SetIText(gitem, s);
  579.  
  580. GetDItem(dlgptr, 15, >ype, &gitem, &gbox);    /* debug level */
  581. sprintf(s, "%2d", debug);
  582. c2pstr(s);
  583. SetIText(gitem, s);
  584. }
  585.  
  586. OSErr hostdlg(unsigned char *s)
  587. {                    /* "s" assumed to be 256 bytes */
  588. DialogPtr dlgptr;
  589. DialogPeek dStorage;
  590. WindowPtr behind;
  591. pascal Boolean (*filterProc) ();
  592. short itemHit, oldHit;
  593. short gtype;
  594. Handle gitem;
  595. Rect gbox;
  596. unsigned char d_hostname[256];
  597. OSErr rc;
  598.  
  599. dStorage = 0;
  600. behind = (WindowPtr)-1;
  601. dlgptr = GetNewDialog(282, dStorage, behind);
  602. ctrwindow(dlgptr);
  603.  
  604. /* copy current values of items */
  605. memcpy(d_hostname, s, 256);
  606.  
  607. /* define host name text */
  608. GetDItem(dlgptr, 4, >ype, &gitem, &gbox);        /* hostname */
  609. c2pstr(d_hostname);
  610. SetIText(gitem, d_hostname);
  611. p2cstr(d_hostname);
  612. SelIText(dlgptr, 4, 0, 32767);
  613. arrowcursor();
  614. ShowWindow(dlgptr);
  615.  
  616. /* frame the default selection */
  617. framedflt(dlgptr);
  618.  
  619. /* loop to process changes */
  620.  
  621. filterProc = DlgFilter;
  622. oldHit = 0;
  623. rc = 1;            /* assume "cancel" */
  624. while (1) {
  625.     ModalDialog(filterProc, &itemHit);
  626.     if ((oldHit > 0) && (oldHit != itemHit))
  627.         switch(oldHit) {
  628.         case 4:                                    /* hostname */
  629.                 GetDItem(dlgptr, 4, >ype, &gitem, &gbox);
  630.                 GetIText(gitem, d_hostname);
  631.                 p2cstr(d_hostname);
  632.                 if (strlen(d_hostname) > 255) {
  633.                     d_hostname[255] = 0;
  634.                     }
  635.                 c2pstr(d_hostname);
  636.                 SetIText(gitem, d_hostname);
  637.                 p2cstr(d_hostname);
  638.                 break;
  639.         default:
  640.                 break;
  641.         }
  642.     oldHit = itemHit;
  643.     switch(itemHit) {
  644.         case 1:                                    /* OK */
  645.                 strcpy(s, d_hostname);
  646.                 rc = 0;
  647.                 break;
  648.         default: break;
  649.         }
  650.     if ((itemHit == 1) || (itemHit == 2)) break;
  651.     }
  652.  
  653. /* dispose of dialog and return */
  654. DisposDialog(dlgptr);
  655. return(rc);
  656. }
  657.  
  658. void featdlg(cnr *cp)
  659. {
  660. DialogPtr dlgptr;
  661. DialogPeek dStorage;
  662. WindowPtr behind;
  663. pascal Boolean (*filterProc) ();
  664. short itemHit;
  665. char d_insreset, d_impnull, d_repnull, d_digitpfk, d_ext3270, d_std_brack;
  666. static unsigned char * ScrDmpEnb = (unsigned char *)0x2f8;
  667.  
  668. dStorage = 0;
  669. behind = (WindowPtr)-1;
  670. dlgptr = GetNewDialog(260, dStorage, behind);
  671. ctrwindow(dlgptr);
  672.  
  673. /* copy current values of items */
  674. d_insreset = cp->cs.insreset;
  675. d_impnull = cp->cs.impnull;
  676. d_repnull = cp->cs.repnull;
  677. d_digitpfk = cp->cs.digitpfk;
  678. d_ext3270 = cp->cs.ext3270;
  679. d_std_brack = cp->cs.std_brack;
  680.  
  681. /* show current values of items */
  682. setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk, d_ext3270,
  683.         d_std_brack);
  684. arrowcursor(); 
  685. ShowWindow(dlgptr);
  686.  
  687. /* frame the default selection */
  688. framedflt(dlgptr);
  689.  
  690. /* loop to process changes */
  691.  
  692. filterProc = DlgFilter;
  693. while (1) {
  694.     ModalDialog(filterProc, &itemHit);
  695.     switch(itemHit) {
  696.         case 1:                                    /* OK */
  697.                 cp->cs.insreset = d_insreset;
  698.                 cp->cs.impnull = d_impnull;
  699.                 cp->cs.repnull = d_repnull;
  700.                 cp->cs.digitpfk = d_digitpfk;
  701.                 cp->cs.ext3270 = d_ext3270;
  702.                 cp->cs.std_brack = d_std_brack;
  703.                 cp->fixbracket = cp->cs.std_brack && (!cp->aplmode) &&
  704.                                  (cp->stdfont != ALAFONT);
  705.                 if (cp->cs.digitpfk) (*ScrDmpEnb) = 0;
  706.                         else  (*ScrDmpEnb) = ScrDmpSav;
  707.                 break;
  708.         case 3:                                    /* yes */
  709.         case 4:                                    /* no */
  710.                 d_insreset = 4 - itemHit;
  711.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  712.                         d_ext3270, d_std_brack);
  713.                 break;
  714.         case 6:                                    /* yes */
  715.         case 7:                                    /* no */
  716.                 d_impnull = 7 - itemHit;
  717.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  718.                         d_ext3270, d_std_brack);
  719.                 break;
  720.         case 9:                                    /* yes */
  721.         case 10:                                /* no */
  722.                 d_repnull = 10 - itemHit;
  723.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  724.                         d_ext3270, d_std_brack);
  725.                 break;
  726.         case 12:                                /* yes */
  727.         case 13:                                /* no */
  728.                 d_digitpfk = 13 - itemHit;
  729.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  730.                         d_ext3270, d_std_brack);
  731.                 break;
  732.         case 15:                                /* yes */
  733.         case 16:                                /* no */
  734.                 d_ext3270 = 16 - itemHit;
  735.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  736.                         d_ext3270, d_std_brack);
  737.                 break;
  738.         case 18:                                /* yes */
  739.         case 19:                                /* no */
  740.                 d_std_brack = 19 - itemHit;
  741.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  742.                         d_ext3270, d_std_brack);
  743.                 break;
  744.         case 20:                            /* set defaults */
  745.                 d_insreset = d_impnull = d_repnull = d_digitpfk = d_ext3270 = 
  746.                     d_std_brack = 1;
  747.                 setfeat(dlgptr, d_insreset, d_impnull, d_repnull, d_digitpfk,
  748.                         d_ext3270, d_std_brack);
  749.                 break;
  750.  
  751.         default: break;
  752.         }
  753.     if ((itemHit == 1) || (itemHit == 21)) break;
  754.     }
  755.  
  756. /* dispose of dialog and return */
  757. DisposDialog(dlgptr);
  758. }
  759.  
  760. void setfeat(DialogPtr dlgptr, char d_insreset, char d_impnull,
  761.              char d_repnull, char d_digitpfk, char d_ext3270, 
  762.              char d_std_brack)
  763. {
  764. setit(3, dlgptr, d_insreset != 0);                /* yes */
  765. setit(4, dlgptr, d_insreset == 0);                /* no */
  766.  
  767. setit(6, dlgptr, d_impnull != 0);                /* yes */
  768. setit(7, dlgptr, d_impnull == 0);                /* no */
  769.  
  770. setit(9, dlgptr, d_repnull != 0);                /* yes */
  771. setit(10, dlgptr, d_repnull == 0);                /* no */
  772.  
  773. setit(12, dlgptr, d_digitpfk != 0);                /* yes */
  774. setit(13, dlgptr, d_digitpfk == 0);                /* no */
  775.  
  776. setit(15, dlgptr, d_ext3270 != 0);                /* yes */
  777. setit(16, dlgptr, d_ext3270 == 0);                /* no */
  778.  
  779. setit(18, dlgptr, d_std_brack != 0);            /* yes */
  780. setit(19, dlgptr, d_std_brack == 0);            /* no */
  781. }
  782.  
  783. short savedlg(char update, cnr *cp)
  784. {
  785. #pragma unused(cp)
  786.  
  787. DialogPtr dlgptr;
  788. DialogPeek dStorage;
  789. WindowPtr behind;
  790. pascal Boolean (*filterProc) ();
  791. short * itemHitPtr;
  792. short itemHit, dlgnum;
  793.  
  794. dStorage = 0;
  795. behind = (WindowPtr)-1;
  796. if (update) dlgnum = 290;
  797. else dlgnum = 261;
  798. dlgptr = GetNewDialog(dlgnum, dStorage, behind);
  799. ctrwindow(dlgptr);
  800. arrowcursor();
  801. ShowWindow(dlgptr);
  802.  
  803. /* frame the default selection */
  804. framedflt(dlgptr);
  805.  
  806. /* loop to process changes */
  807.  
  808. filterProc = DlgFilter;
  809. itemHitPtr = &itemHit;
  810. while (1) {
  811.     ModalDialog(filterProc, itemHitPtr);
  812.     if (itemHit == 1) break;
  813.     if (itemHit == 2) break;
  814.     }
  815. /* dispose of dialog and return */
  816. DisposDialog(dlgptr);
  817. return(2 - itemHit);
  818. }
  819.  
  820. void clickdlg(cnr *cp)
  821. {
  822. DialogPtr dlgptr;
  823. DialogPeek dStorage;
  824. WindowPtr behind;
  825. pascal Boolean (*filterProc) ();
  826. short gtype;
  827. Handle gitem;
  828. Rect mybox;
  829. short itemHit;
  830. short * itemHitPtr;
  831. short savepf, temppf;
  832. GrafPtr gp;
  833.  
  834. dStorage = 0;
  835. behind = (WindowPtr)-1;
  836. dlgptr = GetNewDialog(266, dStorage, behind);
  837. ctrwindow(dlgptr);
  838.  
  839. /* define routine to draw user item */
  840. GetDItem(dlgptr, 4, >ype, &gitem, &mybox);
  841. attnmousepf = cp->cs.mousepf;
  842. SetDItem(dlgptr, 4, gtype, (Handle)attndlg, &mybox);
  843. arrowcursor();
  844. ShowWindow(dlgptr);
  845.  
  846. /* frame the default selection */
  847. framedflt(dlgptr);
  848.  
  849. itemHit = 99;
  850. itemHitPtr = &itemHit;
  851. filterProc = DlgFilter;
  852. savepf = cp->cs.mousepf;
  853. while ((itemHit != 1) && (itemHit != 3)) {
  854.     attnmousepf = cp->cs.mousepf;
  855.     ModalDialog(filterProc, itemHitPtr);
  856.     switch(itemHit) {
  857.         case 1:                /* OK */
  858.                 break;
  859.         case 2:                /* Set Default */
  860.                 mousehit.v = mybox.top + 85;
  861.                 mousehit.h = mybox.left + 279;
  862.                 GetPort(&gp);
  863.                 SetPort(dlgptr);
  864.                 LocalToGlobal(&mousehit);
  865.                 SetPort(gp);
  866.         case 4:                /* Function Keys */
  867.                 GetPort(&gp);
  868.                 SetPort(dlgptr);
  869.                 GlobalToLocal(&mousehit);
  870.                 /* memcpy(&lpoint, &mousehit, 4);     struct -> long */
  871.                 temppf = cp->cs.mousepf;
  872.                 attnmenu(mChooseMsg, (MenuHandle)0, &mybox,
  873.                             mousehit, &(cp->cs.mousepf));
  874.                 if (cp->cs.mousepf == 0) {
  875.                     cp->cs.mousepf = temppf;
  876.                     attnmenu(mChooseMsg, (MenuHandle)0, &mybox,
  877.                                 mousehit, &(cp->cs.mousepf));
  878.                     cp->cs.mousepf = temppf;
  879.                     }
  880.                 SetPort(gp);
  881.                 break;
  882.         case 3:                /* Cancel */
  883.                 cp->cs.mousepf = savepf;
  884.                 break;
  885.         default:
  886.                 break;
  887.         }
  888.     }
  889. DisposDialog(dlgptr);
  890. }
  891.  
  892. void stgalert(unsigned char *kind, unsigned char *routine,
  893.               long amount)
  894. {
  895. unsigned char message[80];
  896. pascal Boolean (*filterProc) ();
  897.  
  898. filterProc = DlgFilter;
  899. sprintf(message, "%s attempt to allocate %ld bytes for %s failed.",
  900.         routine, amount, kind);
  901. dbdlg(message);
  902. StopAlert(263, filterProc);
  903. }
  904.  
  905. void seterr(void)
  906. {
  907. pascal Boolean (*filterProc) ();
  908.  
  909. c2pstr(setmsg1);
  910. c2pstr(setmsg2);
  911. c2pstr(setmsg3);
  912. ParamText(setmsg1, setmsg2, setmsg3, "\p");
  913. p2cstr(setmsg1);
  914. p2cstr(setmsg2);
  915. p2cstr(setmsg3);
  916. filterProc = DlgFilter;
  917. if (strlen(setmsg3) == 0)
  918.     {
  919.     StopAlert(288, filterProc);
  920.     }
  921. else {
  922.     StopAlert(289, filterProc);
  923.     }
  924. ParamText("\p", "\p", "\p", "\p");
  925. }
  926.  
  927. /* code taken from dbprint */
  928. void dbdlg(unsigned char *string)
  929. {
  930.    DialogRecord dStorage;
  931.    Rect boundry;
  932.    char visible = 0, goAway = 0;
  933.    WindowPtr behind = (WindowPtr)-1;
  934.    struct {
  935.       short numitems;
  936.       /* Button stuff */
  937.       long Bhandle;
  938.       short Btop,
  939.             Bleft,
  940.             Bbottom,
  941.             Bright;
  942.       char Btype;
  943.       char Blen;
  944.       unsigned char Btext[2];
  945.       /* Text item */
  946.       long Thandle;
  947.       short Ttop,
  948.             Tleft,
  949.             Tbottom,
  950.             Tright;
  951.       char Ttype;
  952.       char Tlen;
  953.       unsigned char Ttext[255];
  954.       } DStruct;
  955.    DialogPtr theBox;
  956.    short dummy, l;
  957.    Size DSsize;
  958.    Handle itemlist;
  959.    pascal Boolean (*filterProc) ();
  960.    OSErr rc;
  961.  
  962.    if (cf_dblevel == 0) return;
  963.  
  964.    if (mf_bgrnd && notifyavail) {
  965.         c2pstr(string);
  966.         rc = notifymsg(string);
  967.         p2cstr(string);
  968.         if (rc == noErr) return;
  969.         }
  970.  
  971.    filterProc = DlgFilter;
  972.  
  973.    DStruct.numitems = 1;
  974.    DStruct.Thandle =  0;
  975.    DStruct.Ttop = 50;
  976.    DStruct.Tleft = 30;
  977.    DStruct.Tbottom = 100;
  978.    DStruct.Tright = 260;
  979.    DStruct.Ttype =    statText + itemDisable;
  980.    l = strlen(string);
  981.    if (l > 254) l = 254;
  982.    strcpy(DStruct.Ttext, string);
  983.    if (l%2) {
  984.        strcat(DStruct.Ttext, " ");
  985.        l++;
  986.        }
  987.    DStruct.Tlen = l;
  988.    DStruct.Bhandle = 0;
  989.    DStruct.Btop = 10;
  990.    DStruct.Bleft = 160;
  991.    DStruct.Bbottom = 30;
  992.    DStruct.Bright = 240;
  993.    DStruct.Btype = ctrlItem + btnCtrl;
  994.    DStruct.Blen = 2;
  995.    DStruct.Btext[0] = 'O';
  996.    DStruct.Btext[1] = 'K';
  997.  
  998.    boundry.top = 120;
  999.    boundry.left = 120;
  1000.    boundry.bottom = 240;
  1001.    boundry.right = 400;
  1002.  
  1003.    DSsize = sizeof(DStruct) - 255 + l;
  1004.    itemlist = NewHandle(DSsize);
  1005.  
  1006.    memcpy(*itemlist, &DStruct, (short) DSsize);
  1007.  
  1008.    arrowcursor();
  1009.    theBox = NewDialog(&dStorage, &boundry, "\pDebug Text",
  1010.                       visible, dBoxProc, behind, goAway, 0L, itemlist);
  1011.     ctrwindow(theBox);
  1012.     ShowWindow(theBox);
  1013.  
  1014.    /* highlight the default item */
  1015.    framedflt(theBox);
  1016.  
  1017.    ModalDialog(filterProc, &dummy);
  1018.  
  1019.    DisposDialog(theBox);
  1020. }
  1021.  
  1022. void note_err(short code, cnr *cp)
  1023. {
  1024. pascal Boolean (*filterProc) ();
  1025. Handle errtext;
  1026. static char nullstr[1] = {0};
  1027.  
  1028. if (cp != 0) {
  1029.     if (cp->apiopen) {
  1030.         if (cp->apinoalert) return;
  1031.         }
  1032.     }
  1033.  
  1034. errtext = GetResource('STR ', code);
  1035. if (errtext == 0) return;
  1036.  
  1037. if (mf_bgrnd && notifyavail) {
  1038.     if (notifymsg(*errtext) == noErr) return;
  1039.     }
  1040.  
  1041. ParamText(*errtext, nullstr, nullstr, nullstr);
  1042.  
  1043. filterProc = DlgFilter;
  1044. arrowcursor();
  1045. if (code == mapalrt) {
  1046.     NoteAlert(278, filterProc);        /* appears only once */
  1047.     }
  1048. else {
  1049.     NoteAlert(281, filterProc);        /* appears always */
  1050.     }
  1051. ParamText(nullstr, nullstr, nullstr, nullstr);
  1052. }
  1053.  
  1054. void stoperr(short code, cnr *cp)
  1055. {
  1056. pascal Boolean (*filterProc) ();
  1057. Handle errtext;
  1058. static char nullstr[1] = {0};
  1059.  
  1060. if (cp != 0) {
  1061.     if ((cp->apiopen) && (cp->apinoalert)) {
  1062.         return;
  1063.         }
  1064.     }
  1065.  
  1066. errtext = GetResource('STR ', code);
  1067. if (errtext == 0) return;
  1068.  
  1069. if (mf_bgrnd && notifyavail) {
  1070.     if (notifymsg(*errtext) == noErr) return;
  1071.     }
  1072.  
  1073. ParamText(*errtext, nullstr, nullstr, nullstr);
  1074.  
  1075. filterProc = DlgFilter;
  1076. arrowcursor();
  1077. StopAlert(264, filterProc);
  1078.  
  1079. ParamText(nullstr, nullstr, nullstr, nullstr);
  1080. }
  1081.  
  1082. void stopterr(unsigned char *text, cnr *cp)
  1083. {
  1084. pascal Boolean (*filterProc) ();
  1085. static char nullstr[1] = {0};
  1086. OSErr rc;
  1087.  
  1088. if (cp != 0) {
  1089.     if (cp->apiopen) {
  1090.         if (cp->apinoalert) return;
  1091.         }
  1092.     }
  1093.  
  1094. if (mf_bgrnd && notifyavail) {
  1095.     c2pstr(text);
  1096.     rc = notifymsg(text);
  1097.     p2cstr(text);
  1098.     if (rc == noErr) return;
  1099.     }
  1100.  
  1101. c2pstr(text);
  1102. ParamText(text, nullstr, nullstr, nullstr);
  1103. p2cstr(text);
  1104.  
  1105. filterProc = DlgFilter;
  1106. arrowcursor();
  1107. StopAlert(264, filterProc);
  1108.  
  1109. ParamText(nullstr, nullstr, nullstr, nullstr);
  1110. }
  1111.  
  1112. OSErr notifymsg(unsigned char *msg)
  1113. {                        /* msg is Pascal string */
  1114. short i, n;
  1115. nmrmessage *nmp;
  1116. OSErr rc;
  1117.  
  1118. n = -1;
  1119. for (i=0; i < NMRNUM; i++) {
  1120.     if (myNMR[i]->qelem.nmRefCon == 0) {
  1121.         n = i;
  1122.         break;
  1123.         }
  1124.     }
  1125. if (n == -1) return(1);
  1126. nmp = myNMR[n];
  1127. /* copy message text to message structure */
  1128. memcpy(nmp->msg, "\ptn3270: ", 9);
  1129. i = msg[0];
  1130. if (i > 247) i = 247;
  1131. memcpy(nmp->msg+9, msg+1, i);
  1132. nmp->msg[0] += i;
  1133.  
  1134. /* define notification manager request */
  1135. memset(&nmp->qelem, 0, sizeof(NMRec));
  1136. nmp->qelem.qType = nmType;
  1137. nmp->qelem.nmSound = (Handle)-1;
  1138. nmp->qelem.nmStr = nmp->msg;
  1139. nmp->qelem.nmResp = (NMProcPtr)nmproc;        /* calls nmend */
  1140. nmp->qelem.nmRefCon = GetA5();
  1141. rc = NMInstall(&nmp->qelem);
  1142. if (rc != noErr) nmp->qelem.nmRefCon = 0;
  1143. return(rc);
  1144. }
  1145.  
  1146. void nmend(NMRecPtr nmReqPtr)
  1147. {
  1148. NMRemove(nmReqPtr);            /* dequeue request */
  1149. nmReqPtr->nmRefCon = 0;        /* mark as available */
  1150. }
  1151.  
  1152. pascal Boolean DlgFilter(DialogPtr dlg, EventRecord *eventptr,
  1153.                                 short *itemptr)
  1154. {
  1155. #pragma unused(dlg)
  1156. unsigned char i;
  1157.  
  1158. if (havetcp) myStask();
  1159.  
  1160. switch(eventptr->what) {
  1161.     case mouseDown:
  1162.         mousehit = eventptr->where;
  1163.         return(0);
  1164.     case keyDown:
  1165.         i = (eventptr->message & 0x7f);    /* ascii code */
  1166.         if ((i == 0x03) || (i == 0x0d)) {
  1167.             (*itemptr) = 1;
  1168.             return(-1);
  1169.             }
  1170.     default:
  1171.         return(0);
  1172.     }
  1173. }
  1174.  
  1175. pascal Boolean fmtDlgFilter(DialogPtr dlg, EventRecord *eventptr,
  1176.                                    short *itemptr)
  1177. {
  1178. short i;
  1179. GrafPtr gp;
  1180. Point mouseLoc;
  1181. short gtype;
  1182. Handle gitem;
  1183. Rect gbox, toprect, bottomrect;
  1184.  
  1185. if (havetcp) myStask();
  1186.  
  1187. switch(eventptr->what) {
  1188.     case mouseDown:
  1189.     case mouseUp:
  1190.         GetPort(&gp);
  1191.         SetPort(dlg);
  1192.         mouseLoc = eventptr->where;
  1193.         GlobalToLocal(&mouseLoc);
  1194.         SetPort(gp);
  1195.         GetDItem(dlg, 19, >ype, &gitem, &gbox);
  1196.         if (PtInRect(mouseLoc, &gbox)) {
  1197.             if ((eventptr->what) == mouseUp) {
  1198.                 (*itemptr) = 19;
  1199.                 return(-1);
  1200.                 }
  1201.             toprect = bottomrect = gbox;
  1202.             toprect.bottom = bottomrect.top = 
  1203.                 (gbox.top + gbox.bottom) / 2;
  1204.             GetDItem(dlg, 18, >ype, &gitem, &gbox);
  1205.             arrowinc(dlg, 18, gitem, &toprect, &bottomrect, 24, fmtmaxrows);
  1206.             (*itemptr) = 17;
  1207.             return(-1);
  1208.             }
  1209.         GetDItem(dlg, 22, >ype, &gitem, &gbox);
  1210.         if (PtInRect(mouseLoc, &gbox)) {
  1211.             if ((eventptr->what) == mouseUp) {
  1212.                 (*itemptr) = 22;
  1213.                 return(-1);
  1214.                 }
  1215.             toprect = bottomrect = gbox;
  1216.             toprect.bottom = bottomrect.top = 
  1217.                 (gbox.top + gbox.bottom) / 2;
  1218.             GetDItem(dlg, 21, >ype, &gitem, &gbox);
  1219.             arrowinc(dlg, 21, gitem, &toprect, &bottomrect, 80, fmtmaxcols);
  1220.             (*itemptr) = 20;
  1221.             return(-1);
  1222.             }
  1223.         return(0);
  1224.     case keyDown:
  1225.         i = (eventptr->message & 0x7f);    /* ascii code */
  1226.         if ((i == 0x03) || (i == 0x0d)) {
  1227.             (*itemptr) = 1;
  1228.             return(-1);
  1229.             }
  1230.     default:
  1231.         return(0);
  1232.     }
  1233. }
  1234.  
  1235. void arrowinc(DialogPtr dlg, short item, Handle gitem, Rect *increct,
  1236.               Rect *decrect, short min, short max)
  1237. {
  1238. unsigned char result[256];
  1239. register short num;
  1240. static unsigned long * Ticks = (unsigned long *)0x16a;
  1241. unsigned long ticklim;
  1242. GrafPtr gp;
  1243. Point mouseLoc;
  1244.  
  1245. /* get initial value of item, and make valid if necessary */
  1246. GetIText(gitem, result);
  1247. p2cstr(result);
  1248. num = atoi(result);
  1249. if (num < min) num = min;
  1250. if (num > max) num = max;
  1251. sprintf(result, "%d", num);
  1252. c2pstr(result);
  1253. SetIText(gitem, result);
  1254. if (item == (((DialogPeek)dlg)->editField)+1) {
  1255.     SelIText(dlg, item, 0, 32767);
  1256.     }
  1257.  
  1258. /* change value while mouse is down and in rectangle */
  1259. ticklim = (*Ticks);
  1260. while (StillDown()) {
  1261.     if ((*Ticks) >= ticklim) {
  1262.         ticklim = (*Ticks) + 7;
  1263.         GetPort(&gp);
  1264.         SetPort(dlg);
  1265.         GetMouse(&mouseLoc);
  1266.         SetPort(gp);
  1267.         if (PtInRect(mouseLoc, increct)) {
  1268.             if (num == max) continue;
  1269.             num++;
  1270.             }
  1271.         else if (PtInRect(mouseLoc, decrect)) {
  1272.             if (num == min) continue;
  1273.             num--;
  1274.             }
  1275.         else continue;
  1276.         sprintf(result, "%d", num);
  1277.         c2pstr(result);
  1278.         SetIText(gitem, result);
  1279.         if (item == (((DialogPeek)dlg)->editField)+1) {
  1280.             SelIText(dlg, item, 0, 32767);
  1281.             }
  1282.         }
  1283.     }
  1284. }
  1285.  
  1286. pascal Boolean ListDlgFilter(DialogPtr dlg, EventRecord *eventptr,
  1287.                                     short *itemptr)
  1288. {
  1289. unsigned char i;
  1290. Rect itemRect;
  1291. short itemType;
  1292. Handle itemHandle;
  1293. Point where;
  1294. ListHandle list;
  1295. GrafPtr gp;
  1296.  
  1297. if (havetcp) myStask();
  1298.  
  1299. switch(eventptr->what) {
  1300.     case mouseDown:
  1301.         GetPort(&gp);
  1302.         SetPort(dlg);
  1303.         GetDItem(dlg, 14, &itemType, &itemHandle, &itemRect);
  1304.         where = eventptr->where;
  1305.         GlobalToLocal(&where);
  1306.         if (PtInRect(where, &itemRect)) {
  1307.             *itemptr = 14;
  1308.             itemRect.right -= 15;
  1309.             if (PtInRect(where, &itemRect)) {
  1310.                 *itemptr = 16;
  1311.                 }
  1312.             list = (ListHandle)((DialogPeek)dlg)->window.refCon;
  1313.             LClick(where, eventptr->modifiers, list);
  1314.             SetPort(gp);
  1315.             return(-1);
  1316.             }
  1317.         else {
  1318.             SetPort(gp);
  1319.             return(0);
  1320.             }
  1321.         break;
  1322.     case keyDown:
  1323.         i = (eventptr->message & 0x7f);    /* ascii code */
  1324.         if ((i == 0x03) || (i == 0x0d)) {
  1325.             (*itemptr) = 1;
  1326.             return(-1);
  1327.             }
  1328.     default:
  1329.         return(0);
  1330.     }
  1331. }
  1332.  
  1333. void xfdlg(short code, unsigned char *msg1, unsigned char *msg2,
  1334.            unsigned char *msg3, unsigned char *msg4, cnr *cp)
  1335. {
  1336. Ptr dStorage;
  1337. WindowPtr behind;
  1338. GrafPtr temp;
  1339. struct WStateData * wsptr;
  1340. struct WindowRecord * xtemp;
  1341. Point p;
  1342.  
  1343. switch (code) {
  1344.     case 0:    
  1345.             dStorage = (Ptr)&(cp->dlgrec);
  1346.             behind = (WindowPtr)-1;
  1347.             cp->xdlgptr = GetNewDialog(267, dStorage, behind);
  1348.             ctrwindow(cp->xdlgptr);
  1349.             ShowWindow(cp->xdlgptr);
  1350.             xtemp = (struct WindowRecord *)cp->xdlgptr;
  1351.             if (xtemp->dataHandle != 0) {
  1352.                 wsptr = (struct WStateData *)*(xtemp->dataHandle);
  1353.                 wsptr->stdState = (cp->xdlgptr)->portRect;
  1354.                 GetPort(&temp);
  1355.                 SetPort(cp->xdlgptr);
  1356.                 p.h = wsptr->stdState.left;
  1357.                 p.v = wsptr->stdState.top;
  1358.                 LocalToGlobal(&p);
  1359.                 wsptr->stdState.left = p.h;
  1360.                 wsptr->stdState.top = p.v;
  1361.                 p.h = wsptr->stdState.right;
  1362.                 p.v = wsptr->stdState.bottom;
  1363.                 LocalToGlobal(&p);
  1364.                 wsptr->stdState.right = p.h;
  1365.                 wsptr->stdState.bottom = p.v;
  1366.                 SetPort(temp);
  1367.                 }
  1368.             cp->xdlg = 1;
  1369.             cp->msg1flg = 0;
  1370.             return;
  1371.     case 1:    
  1372.             if (cp->msg1flg == 0) { 
  1373.                 cp->msg1flg = 1;
  1374.                 settext(cp->xdlgptr, 1, msg1);
  1375.                 }
  1376.             settext(cp->xdlgptr, 3, msg2);
  1377.             settext(cp->xdlgptr, 5, msg3);
  1378.             settext(cp->xdlgptr, 7, msg4);
  1379.             xfGrowIcon(cp);
  1380.             return;
  1381.     default:
  1382.             if (cp->xdlg == 0) return;
  1383.             cp->xdlg = 0;
  1384.             DisposDialog(cp->xdlgptr);
  1385.             return;
  1386.     }
  1387. }
  1388.  
  1389. void cf_fmtdlg(void)
  1390. {
  1391. register DialogPtr dlgptr;
  1392. Ptr dStorage;
  1393. WindowPtr behind;
  1394. pascal Boolean (*filterProc) ();
  1395. short itemHit, lasthit;
  1396. short * itemHitPtr;
  1397. short gtype;
  1398. Handle gitem;
  1399. Rect gbox;
  1400. short dfltptsize, altptsize;
  1401. short altrows, altcols;
  1402. short custrows, custcols;
  1403. char windmax, changed, customflag, skipflag, savewpos;
  1404. unsigned char result[256], newnum[10];
  1405. short i;
  1406.  
  1407. dStorage = 0;
  1408. behind = (WindowPtr)-1;
  1409. dlgptr = GetNewDialog(269, dStorage, behind);
  1410. ctrwindow(dlgptr);
  1411. filterProc = fmtDlgFilter;
  1412. itemHitPtr = &itemHit;
  1413.  
  1414. /* define routine to draw user items */
  1415. GetDItem(dlgptr, 19, >ype, &gitem, &gbox);
  1416. SetDItem(dlgptr, 19, gtype, (Handle)arrowproc, &gbox);
  1417. GetDItem(dlgptr, 22, >ype, &gitem, &gbox);
  1418. SetDItem(dlgptr, 22, gtype, (Handle)arrowproc, &gbox);
  1419. arrowcursor();
  1420. ShowWindow(dlgptr);
  1421. /* frame the default selection */
  1422. framedflt(dlgptr);
  1423.  
  1424. /* copy current settings */
  1425. windmax = cf_windmax;
  1426. dfltptsize = cf_dfltptsize;
  1427. altptsize = cf_altptsize;
  1428. altrows = cf_altrows;
  1429. altcols = cf_altcols;
  1430. custrows = cf_custrows;
  1431. custcols = cf_custcols;
  1432. savewpos = cf_savewpos;
  1433.  
  1434. /* adjust settings to be valid */
  1435. adjfmt(&changed, &windmax, &dfltptsize, &altptsize, &altrows, &altcols);
  1436. if (altptsize == 9) {
  1437.     fmtmaxrows = rowmax9;
  1438.     fmtmaxcols = colmax9;
  1439.     }
  1440. else {
  1441.     fmtmaxrows = rowmax12;
  1442.     fmtmaxcols = colmax12;
  1443.     }
  1444. if (custrows < 24) custrows = 24;
  1445. if (custcols < 80) custcols = 80;
  1446. if (custrows > fmtmaxrows) custrows = fmtmaxrows;
  1447. if (custcols > fmtmaxcols) custcols = fmtmaxcols;
  1448. if (((altrows == 24) && (altcols == 80)) ||
  1449.     ((altrows == 32) && (altcols == 80)) ||
  1450.     ((altrows == 43) && (altcols == 80)) ||
  1451.     ((altrows == 27) && (altcols == 132))) {
  1452.     customflag = 0;
  1453.     }
  1454. else {
  1455.     customflag = 1;
  1456.     custrows = altrows;
  1457.     custcols = altcols;
  1458.     }
  1459.  
  1460. /* display initial settings */
  1461. setcffmt(dlgptr, 99, dfltptsize, windmax, altptsize, 
  1462.        altrows, altcols, customflag, custrows, custcols, savewpos);
  1463.  
  1464. itemHit = 99;
  1465. lasthit = 99;
  1466. while (1) {
  1467.     ModalDialog(filterProc, itemHitPtr);
  1468.     if (((lasthit == 18) && (itemHit != 18)) || 
  1469.         ((lasthit == 21) && (itemHit != 21)) ||
  1470.         (itemHit == 19) || (itemHit == 22)) {
  1471.         if ((lasthit == 18) || (itemHit == 19)) {
  1472.             GetDItem(dlgptr, 18, >ype, &gitem, &gbox);
  1473.             GetIText(gitem, result);
  1474.             p2cstr(result);
  1475.             custrows = atoi(result);
  1476.             if (custrows < 24) custrows = 24;
  1477.             if (custrows > fmtmaxrows) custrows = fmtmaxrows;
  1478.             if (customflag) altrows = custrows;
  1479.             }
  1480.         else {
  1481.             GetDItem(dlgptr, 21, >ype, &gitem, &gbox);
  1482.             GetIText(gitem, result);
  1483.             p2cstr(result);
  1484.             custcols = atoi(result);
  1485.             if (custcols < 80) custcols = 80;
  1486.             if (custcols > fmtmaxcols) custcols = fmtmaxcols;
  1487.             if (customflag) altcols = custcols;
  1488.             }
  1489.         }
  1490.     if (itemHit < 3) break;
  1491.     skipflag = 0;
  1492.     switch (itemHit) {
  1493.         case 3:        dfltptsize = altptsize = 12;
  1494.                     windmax = ds.windmax;
  1495.                     altrows = 24;
  1496.                     altcols = 80;
  1497.                     adjfmt(&changed, &windmax, &dfltptsize, 
  1498.                            &altptsize, &altrows, &altcols);
  1499.                     if (altptsize == 9) {
  1500.                         fmtmaxrows = rowmax9;
  1501.                         fmtmaxcols = colmax9;
  1502.                         }
  1503.                     else {
  1504.                         fmtmaxrows = rowmax12;
  1505.                         fmtmaxcols = colmax12;
  1506.                         }
  1507.                     customflag = 0;
  1508.                     custcols = fmtmaxcols;
  1509.                     custrows = fmtmaxrows;
  1510.                     savewpos = ds.savewpos;
  1511.                     break;
  1512.         case 5:        dfltptsize = 9;
  1513.                     break;
  1514.         case 6:        dfltptsize = 12;
  1515.                     break;
  1516.         case 7:        windmax ^= 1;
  1517.                     break;
  1518.         case 8:        savewpos ^= 1;
  1519.                     break;
  1520.         case 10:    altptsize = 9;
  1521.                     fmtmaxrows = rowmax9;
  1522.                     fmtmaxcols = colmax9;
  1523.                     break;
  1524.         case 11:    altptsize = 12;
  1525.                     fmtmaxrows = rowmax12;
  1526.                     fmtmaxcols = colmax12;
  1527.                     if (custrows > fmtmaxrows) custrows = fmtmaxrows;
  1528.                     if (custcols > fmtmaxcols) custcols = fmtmaxcols;
  1529.                     if (customflag) {
  1530.                         altrows = custrows;
  1531.                         altcols = custcols;
  1532.                         }
  1533.                     else {
  1534.                         if ((altrows > fmtmaxrows) || (altcols > fmtmaxcols)) {
  1535.                             altrows = 24;
  1536.                             altcols = 80;
  1537.                             }
  1538.                         }
  1539.                     break;                    
  1540.         case 12:    altrows = 24;
  1541.                     altcols = 80;
  1542.                     customflag = 0;
  1543.                     break;
  1544.         case 13:    altrows = 32;
  1545.                     altcols = 80;
  1546.                     customflag = 0;
  1547.                     break;
  1548.         case 14:    altrows = 43;
  1549.                     altcols = 80;
  1550.                     customflag = 0;
  1551.                     break;
  1552.         case 15:    altrows = 27;
  1553.                     altcols = 132;
  1554.                     customflag = 0;
  1555.                     break;
  1556.         case 16:                            /* "custom" button and arrows */
  1557.         case 19:
  1558.         case 22:
  1559.                     altrows = custrows;
  1560.                     altcols = custcols;
  1561.                     customflag = 1;
  1562.                     break;
  1563.         case 18:
  1564.         case 21:
  1565.                     altrows = custrows;        /* include selecting "custom" */
  1566.                     altcols = custcols;
  1567.                     customflag = 1;
  1568.                     
  1569.                     GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  1570.                     GetIText(gitem, result);
  1571.                     p2cstr(result);
  1572.                     i = 0;
  1573.                     while (result[i] != 0) {
  1574.                         if ((result[i] != 0x20) && ((result[i] < 0x30) ||
  1575.                             (result[i] > 0x39))) {
  1576.                             SysBeep(1);
  1577.                             break;
  1578.                             }
  1579.                         i++;
  1580.                         }
  1581.                     i = atoi(result) % 1000;
  1582.                     if (i == 0) {
  1583.                         newnum[0] = 0;
  1584.                         }
  1585.                     else {
  1586.                         sprintf(newnum, "%d", i);
  1587.                         }
  1588.                     if (strcmp(result, newnum) != 0) {
  1589.                         c2pstr(newnum);
  1590.                         SetIText(gitem, newnum);
  1591.                         }
  1592.                     break;
  1593.         default:
  1594.                     skipflag = 1;
  1595.                     break;
  1596.         }
  1597.     if (!skipflag) setcffmt(dlgptr, itemHit, dfltptsize, windmax, altptsize, 
  1598.                        altrows, altcols, customflag, custrows, custcols, savewpos);
  1599.     lasthit = itemHit;
  1600.     }
  1601. DisposDialog(dlgptr);
  1602. if (itemHit == 1) {
  1603.     cf_windmax = windmax;
  1604.     cf_dfltptsize = dfltptsize;
  1605.     cf_altptsize = altptsize;
  1606.     cf_altrows = altrows;
  1607.     cf_altcols = altcols;
  1608.     cf_custrows = custrows;
  1609.     cf_custcols = custcols;
  1610.     cf_savewpos = savewpos;
  1611.     }
  1612. }
  1613.  
  1614. setcffmt(DialogPtr dlgptr, short itemHit, short dfltptsize, char windmax,
  1615.        short altptsize, short altrows, short altcols, char customflag,
  1616.        short custrows, short custcols, char savewpos)
  1617. {
  1618. short crows, ccols;
  1619. short gtype;
  1620. Handle gitem;
  1621. Rect gbox;
  1622. unsigned char result[256], newnum[10];
  1623.  
  1624. if (itemHit == 18) {
  1625.     GetDItem(dlgptr, 18, >ype, &gitem, &gbox);
  1626.     GetIText(gitem, result);
  1627.     p2cstr(result);
  1628.     crows = atoi(result);
  1629.     }
  1630. else crows = custrows;
  1631. if (itemHit == 21) {
  1632.     GetDItem(dlgptr, 21, >ype, &gitem, &gbox);
  1633.     GetIText(gitem, result);
  1634.     p2cstr(result);
  1635.     ccols = atoi(result);
  1636.     }
  1637. else ccols = custcols;
  1638. setactive(1, dlgptr,
  1639.     !(customflag && ((crows > fmtmaxrows) || (ccols > fmtmaxcols) ||
  1640.                       (crows < 24) || (ccols < 80))));
  1641. setit(5, dlgptr, dfltptsize == 9);
  1642. setit(6, dlgptr, dfltptsize == 12);
  1643. setactive(6, dlgptr, (rowmax12 >= 24) && (colmax12 >= 80));
  1644. setit(7, dlgptr, windmax);
  1645. setit(8, dlgptr, savewpos);
  1646. setit(10, dlgptr, altptsize == 9);
  1647. setit(11, dlgptr, altptsize == 12);
  1648. setactive(11, dlgptr, (rowmax12 >= 24) && (colmax12 >= 80));
  1649. setit(12, dlgptr, (altrows == 24) && (altcols == 80) && (!customflag));
  1650. setit(13, dlgptr, (altrows == 32) && (altcols == 80) && (!customflag));
  1651. setactive(13, dlgptr, fmtmaxrows >= 32);
  1652. setit(14, dlgptr, (altrows == 43) && (altcols == 80) && (!customflag));
  1653. setactive(14, dlgptr, fmtmaxrows >= 43);
  1654. setit(15, dlgptr, (altrows == 27) && (altcols == 132) && (!customflag));
  1655. setactive(15, dlgptr, (fmtmaxrows >= 27) && (fmtmaxcols >= 132));
  1656. setit(16, dlgptr, customflag);
  1657.  
  1658. if (itemHit != 18) {
  1659.     GetDItem(dlgptr, 18, >ype, &gitem, &gbox);
  1660.     GetIText(gitem, result);
  1661.     p2cstr(result);
  1662.     sprintf(newnum, "%d", custrows);
  1663.     if (strcmp(result, newnum) != 0) {
  1664.         c2pstr(newnum);
  1665.         SetIText(gitem, newnum);
  1666.         }
  1667.     }
  1668.  
  1669. if (itemHit != 21) {
  1670.     GetDItem(dlgptr, 21, >ype, &gitem, &gbox);
  1671.     GetIText(gitem, result);
  1672.     p2cstr(result);
  1673.     sprintf(newnum, "%d", custcols);
  1674.     if (strcmp(result, newnum) != 0) {
  1675.         c2pstr(newnum);
  1676.         SetIText(gitem, newnum);
  1677.         }
  1678.     }
  1679. }
  1680.  
  1681. pascal void arrowproc(WindowPtr dlgwindow, short item)
  1682. {
  1683. GrafPtr gp;
  1684. Rect myrect;
  1685. short dtype;
  1686. Handle ditem;
  1687. PolyHandle ph;
  1688.  
  1689. GetDItem(dlgwindow, item, &dtype, &ditem, &myrect);
  1690. GetPort(&gp);
  1691. SetPort(dlgwindow);
  1692. FrameRoundRect(&myrect, 8, 8);
  1693.  
  1694. ph = OpenPoly();
  1695. MoveTo(myrect.left+2, myrect.top+5);
  1696. LineTo(myrect.left+5, myrect.top+2);
  1697. LineTo(myrect.left+8, myrect.top+5);
  1698. LineTo(myrect.left+6, myrect.top+5);
  1699. LineTo(myrect.left+6, myrect.top+7);
  1700. LineTo(myrect.left+4, myrect.top+7);
  1701. LineTo(myrect.left+4, myrect.top+5);
  1702. LineTo(myrect.left+2, myrect.top+5);
  1703. ClosePoly();
  1704. FramePoly(ph);
  1705. PaintPoly(ph);
  1706. KillPoly(ph);
  1707.  
  1708. ph = OpenPoly();
  1709. MoveTo(myrect.left+2, myrect.top+12);
  1710. LineTo(myrect.left+5, myrect.top+15);
  1711. LineTo(myrect.left+8, myrect.top+12);
  1712. LineTo(myrect.left+6, myrect.top+12);
  1713. LineTo(myrect.left+6, myrect.top+10);
  1714. LineTo(myrect.left+4, myrect.top+10);
  1715. LineTo(myrect.left+4, myrect.top+12);
  1716. LineTo(myrect.left+2, myrect.top+12);
  1717. ClosePoly();
  1718. FramePoly(ph);
  1719. PaintPoly(ph);
  1720. KillPoly(ph);
  1721.  
  1722. SetPort(gp);
  1723. }
  1724.  
  1725. void fmtdlg(cnr *cp)
  1726. {
  1727. register DialogPtr dlgptr;
  1728. Ptr dStorage;
  1729. WindowPtr behind;
  1730. pascal Boolean (*filterProc) ();
  1731. short itemHit;
  1732. short gtype;
  1733. Handle gitem;
  1734. Rect gbox;
  1735. short dfltptsize, altptsize;
  1736. char windmax, savewpos, skipflag;
  1737. unsigned char result[256];
  1738.  
  1739. dStorage = 0;
  1740. behind = (WindowPtr)-1;
  1741. dlgptr = GetNewDialog(259, dStorage, behind);
  1742. ctrwindow(dlgptr);
  1743. filterProc = DlgFilter;
  1744.  
  1745. arrowcursor();
  1746. ShowWindow(dlgptr);
  1747. /* frame the default selection */
  1748. framedflt(dlgptr);
  1749.  
  1750. /* copy current settings */
  1751. windmax = cp->cs.windmax;
  1752. dfltptsize = cp->cs.dfltptsize;
  1753. altptsize = cp->cs.altptsize;
  1754. savewpos = cp->cs.savewpos;
  1755.  
  1756. /* disable 12-point buttons if not valid for screen size */
  1757. setactive(6, dlgptr, (rowmax12 >= 24) && (colmax12 >= 80));
  1758. setactive(11, dlgptr,
  1759.           (rowmax12 >= cp->cs.altrows) && (colmax12 >= cp->cs.altcols));
  1760.  
  1761. /* set text for large screen format heading */
  1762. sprintf(result, "Large Screen Format (%d-by-%d):",
  1763.         cp->cs.altrows, cp->cs.altcols);
  1764. c2pstr(result);
  1765. GetDItem(dlgptr, 9, >ype, &gitem, &gbox);
  1766. SetIText(gitem, result);
  1767.  
  1768. /* display initial settings */
  1769. setfmt(dlgptr, dfltptsize, windmax, altptsize, savewpos); 
  1770.  
  1771. while (1) {
  1772.     ModalDialog(filterProc, &itemHit);
  1773.     if (itemHit < 3) break;
  1774.     skipflag = 0;
  1775.     switch (itemHit) {
  1776.         case 3:        if ((rowmax12 >= 24) && (colmax12 >= 80)) {
  1777.                         dfltptsize = 12;
  1778.                         }
  1779.                     else {
  1780.                         dfltptsize = 9;
  1781.                         }
  1782.                     if ((rowmax12 >= cp->cs.altrows) &&
  1783.                         (colmax12 >= cp->cs.altcols)) {
  1784.                         altptsize = 12;
  1785.                         }
  1786.                     else {
  1787.                         altptsize = 9;
  1788.                         }
  1789.                     windmax = ds.windmax;
  1790.                     savewpos = ds.savewpos;
  1791.                     break;
  1792.         case 5:        dfltptsize = 9;
  1793.                     break;
  1794.         case 6:        dfltptsize = 12;
  1795.                     break;
  1796.         case 7:        windmax ^= 1;
  1797.                     break;
  1798.         case 8:        savewpos ^= 1;
  1799.                     break;
  1800.         case 10:    altptsize = 9;
  1801.                     break;
  1802.         case 11:    altptsize = 12;
  1803.                     break;                    
  1804.         default:    skipflag = 1;
  1805.                     break;
  1806.         }
  1807.     if (!skipflag) setfmt(dlgptr, dfltptsize, windmax, altptsize, savewpos); 
  1808.     }
  1809. DisposDialog(dlgptr);
  1810. if (itemHit == 1) {
  1811.     cp->cs.windmax = windmax;
  1812.     cp->cs.dfltptsize = dfltptsize;
  1813.     cp->cs.altptsize = altptsize;
  1814.     cp->cs.savewpos = savewpos;
  1815.     newmode(cp->cur_mode, 0, cp);
  1816.     }
  1817. }
  1818.  
  1819. void setfmt(DialogPtr dlgptr, short dfltptsize, char windmax,
  1820.             short altptsize, char savewpos) 
  1821. {
  1822. setit(5, dlgptr, dfltptsize == 9);
  1823. setit(6, dlgptr, dfltptsize == 12);
  1824. setit(7, dlgptr, windmax);
  1825. setit(8, dlgptr, savewpos);
  1826. setit(10, dlgptr, altptsize == 9);
  1827. setit(11, dlgptr, altptsize == 12);
  1828. }
  1829.  
  1830. void miscdlg(cnr *cp)
  1831. {
  1832. register DialogPtr dlgptr;
  1833. Ptr dStorage;
  1834. WindowPtr behind;
  1835. pascal Boolean (*filterProc) ();
  1836. short itemHit;
  1837. short * itemHitPtr;
  1838. short gtype;
  1839. Handle gitem;
  1840. Rect gbox;
  1841. char newtime, newblock, newpos;
  1842. char newauto, newkeep;
  1843. GrafPtr gp;
  1844. ListHandle list;
  1845. Rect dataBounds;
  1846. Point cellSize, cell;
  1847. short i, sndcount, namelen;
  1848. char loadflag;
  1849. Handle reshandle, reshandle2;
  1850. short resid;
  1851. ResType restype;
  1852. unsigned char resname[256];
  1853. OSErr rc;
  1854.  
  1855. dStorage = 0;
  1856. behind = (WindowPtr)-1;
  1857. dlgptr = GetNewDialog(271, dStorage, behind);
  1858. ctrwindow(dlgptr);
  1859. if (newroms) {
  1860.     filterProc = ListDlgFilter;
  1861.     }
  1862. else {
  1863.     filterProc = DlgFilter;
  1864.     }
  1865. itemHitPtr = &itemHit;
  1866. GetPort(&gp);
  1867. SetPort(dlgptr);
  1868.  
  1869. /* define routine to draw user items */
  1870. GetDItem(dlgptr, 13, >ype, &gitem, &gbox);
  1871. SetDItem(dlgptr, 13, gtype, (Handle)misctext, &gbox);
  1872.  
  1873. GetDItem(dlgptr, 14, >ype, &gitem, &gbox);
  1874. SetDItem(dlgptr, 14, gtype, (Handle)listproc, &gbox);
  1875.  
  1876. if (newroms) {
  1877.     /* make room for scroll bar */
  1878.     gbox.right -= 15;
  1879.  
  1880.     /* create a list */
  1881.     dataBounds.top = dataBounds.left = 0;
  1882.     sndcount = CountResources('snd ');
  1883.     dataBounds.bottom = sndcount + 1;
  1884.     dataBounds.right = 1;
  1885.     cellSize.h = cellSize.v = 0;    /* use defaults */
  1886.     list = LNew(&gbox, &dataBounds, cellSize, 0, (WindowPtr)dlgptr,
  1887.                 false, false, false, true);
  1888.  
  1889.     /* allow the dialog manager routines to access the list record */
  1890.     ((DialogPeek)dlgptr)->window.refCon = (long)list;
  1891.  
  1892.     /* allow only one selection at a time */
  1893.     (*list)->selFlags = lOnlyOne;
  1894.     }
  1895. else {
  1896.     setactive(13, dlgptr, 0);
  1897.     }
  1898.  
  1899. setit(4, dlgptr, cp->cs.stat_time==1);
  1900. setit(5, dlgptr, cp->cs.stat_time==2);
  1901. setit(6, dlgptr, cp->cs.stat_time==0);
  1902. setit(8, dlgptr, cp->cs.blockcurs==0);
  1903. setit(9, dlgptr, cp->cs.blockcurs);
  1904. setit(10, dlgptr, cp->cs.curpos);
  1905. setit(11, dlgptr, cp->cs.autoconn);
  1906. setit(12, dlgptr, cp->cs.keepwindow);
  1907.  
  1908. if (newroms) {
  1909.     /* Initialize cell contents */
  1910.     cell.h = cell.v = 0;
  1911.     strcpy(resname, dssndname);
  1912.     namelen = strlen(resname);
  1913.     LSetCell(resname, namelen, cell, list);
  1914.     if (strcmp(resname, cp->cssndname) == 0) LSetSelect(true, cell, list);
  1915.     if (sndcount > 0) {
  1916.         for (i=1; i <= sndcount; i++) {
  1917.             cell.v++;
  1918.             loadflag = 0;
  1919.             SetResLoad(false);
  1920.             reshandle = GetIndResource('snd ', i);
  1921.             SetResLoad(true);
  1922.             if (reshandle == 0) {
  1923.                 loadflag = 1;
  1924.                 reshandle = GetIndResource('snd ', i);
  1925.                 }        
  1926.             if (reshandle != 0) {
  1927.                 getsndinfo(reshandle, &resid, &restype, resname);
  1928.                 if (loadflag) ReleaseResource(reshandle);
  1929.                 namelen = strlen(resname);
  1930.                 LSetCell(resname, namelen, cell, list);
  1931.                 if (strcmp(resname, cp->cssndname) == 0)
  1932.                     LSetSelect(true, cell, list);
  1933.                 }
  1934.             }
  1935.         }
  1936.     LAutoScroll(list);
  1937.     LDoDraw(true, list);
  1938.     }
  1939.  
  1940. newtime = cp->cs.stat_time;
  1941. newblock = cp->cs.blockcurs;
  1942. newpos = cp->cs.curpos;
  1943. newauto = cp->cs.autoconn;
  1944. newkeep = cp->cs.keepwindow;
  1945.  
  1946. arrowcursor();
  1947. ShowWindow(dlgptr);
  1948. /* frame the default selection */
  1949. framedflt(dlgptr);
  1950.  
  1951. itemHit = 99;
  1952. resname[0] = 0;
  1953. while (itemHit > 2) {
  1954.     ModalDialog(filterProc, itemHitPtr);
  1955.     switch (itemHit) {
  1956.         case 4:
  1957.             newtime = 1;
  1958.             break;
  1959.         case 5:
  1960.             newtime = 2;
  1961.             break;
  1962.         case 6:
  1963.             newtime = 0;
  1964.             break;
  1965.         case 8:
  1966.             newblock = 0;
  1967.             break;
  1968.         case 9:
  1969.             newblock = 1;
  1970.             break;
  1971.         case 10:
  1972.             newpos ^= 1;
  1973.             break;
  1974.         case 11:
  1975.             newauto ^= 1;
  1976.             break;
  1977.         case 12:
  1978.             newkeep ^= 1;
  1979.             break;
  1980.         case 14:
  1981.         case 16:
  1982.             if (!newroms) {
  1983.                 beep(cp);
  1984.                 break;
  1985.                 }
  1986.             resname[0] = 0;
  1987.             cell.h = 0;
  1988.             for (cell.v=0; cell.v < sndcount+1; cell.v++) {
  1989.                 if (LGetSelect(false, &cell, list)) {
  1990.                     namelen = 255;
  1991.                     LGetCell(resname, &namelen, cell, list);
  1992.                     resname[namelen] = 0;
  1993.                     break;
  1994.                     }
  1995.                 }
  1996.             if ((strlen(resname) > 0) && (itemHit == 16)) {
  1997.                 if (strcmp(resname, dssndname) == 0) {
  1998.                     SysBeep(3);
  1999.                     }
  2000.                 else {
  2001.                     dlgplaysound(resname);
  2002.                     }
  2003.                 }
  2004.             break;
  2005.         default:
  2006.             break;
  2007.         }
  2008.     if ((itemHit >= 4) && (itemHit <= 12)) {
  2009.         setit(4, dlgptr, newtime==1);
  2010.         setit(5, dlgptr, newtime==2);
  2011.         setit(6, dlgptr, newtime==0);
  2012.         setit(8, dlgptr, newblock==0);
  2013.         setit(9, dlgptr, newblock);
  2014.         setit(10, dlgptr, newpos);
  2015.         setit(11, dlgptr, newauto);
  2016.         setit(12, dlgptr, newkeep);
  2017.         }
  2018.     }
  2019. if (newroms) {
  2020.     LDispose(list);
  2021.     }
  2022. SetPort(gp);
  2023. DisposDialog(dlgptr);
  2024. if (itemHit == 1) {
  2025.     if (cp->cs.stat_time != newtime) {
  2026.         cp->cs.stat_time = newtime;
  2027.         if (cp->myWindow != 0) newstat(cp);
  2028.         }
  2029.     if (cp->cs.blockcurs != newblock) {
  2030.         cp->cs.blockcurs = newblock;
  2031.         if (cp->myWindow != 0) newcur(cp);
  2032.         }
  2033.     if (cp->cs.curpos != newpos) {
  2034.         cp->cs.curpos = newpos;
  2035.         if (cp->myWindow != 0) newstat(cp);
  2036.         }
  2037.     cp->cs.autoconn = newauto;
  2038.     cp->cs.keepwindow = newkeep;
  2039.     if ((strcmp(cp->cssndname, resname) != 0) && (resname[0] != 0)) {
  2040.         if (strcmp(resname, dssndname) == 0) {
  2041.             if (sndactive) {
  2042.                 SndDisposeChannel(scp, true);
  2043.                 sndactive = 0;
  2044.                 }
  2045.             if (cp->sndhandle != 0) DisposHandle(cp->sndhandle);
  2046.             cp->sndhandle = 0;
  2047.             strcpy(cp->cssndname, resname);
  2048.             }
  2049.         else {
  2050.             reshandle = reshandle2 = getsndresource(resname);
  2051.             if (reshandle != 0) {
  2052.                 rc = HandToHand(&reshandle2);
  2053.                 if (rc != noErr) {
  2054.                     ReleaseResource(reshandle);
  2055.                     stoperr(sdmemalrt, cp);
  2056.                     }
  2057.                 else {
  2058.                     getsndinfo(reshandle, &resid, &restype, resname);
  2059.                     ReleaseResource(reshandle);
  2060.                     if (sndactive) {
  2061.                         SndDisposeChannel(scp, true);
  2062.                         sndactive = 0;
  2063.                         }
  2064.                     if (cp->sndhandle != 0) DisposHandle(cp->sndhandle);
  2065.                     cp->sndhandle = reshandle2;
  2066.                     strcpy(cp->cssndname, resname);
  2067.                     }
  2068.                 }
  2069.             }
  2070.         }
  2071.     }
  2072. }
  2073.  
  2074. void dlgplaysound(unsigned char *sndname)
  2075. {
  2076. Handle temph, temph2;
  2077. OSErr rc;
  2078. SndChannelPtr default_scp;
  2079.  
  2080. temph = temph2 = getsndresource(sndname);
  2081. if (temph == 0) return;
  2082. rc = HandToHand(&temph2);
  2083. ReleaseResource(temph);
  2084. if (rc == noErr) {
  2085.     if (sndactive) {
  2086.         SndDisposeChannel(scp, true);
  2087.         sndactive = 0;
  2088.         }
  2089.     default_scp = 0;
  2090.     rc = SndNewChannel(&default_scp, 0, 0L, 0L);
  2091.     if (rc == noErr) {
  2092.         SndPlay(default_scp, temph2, 0);
  2093.         SndDisposeChannel(default_scp, 0);
  2094.         }
  2095.     DisposHandle(temph2);
  2096.     }
  2097. }
  2098.  
  2099. pascal void listproc(DialogPtr dialog, short itemNo)
  2100. {
  2101. ListHandle list;
  2102. short itemType;
  2103. Handle itemHandle;
  2104. Rect itemRect;
  2105.  
  2106. GetDItem(dialog, itemNo, &itemType, &itemHandle, &itemRect);
  2107. if (newroms) {
  2108.     list = (ListHandle)((DialogPeek)dialog)->window.refCon;
  2109.     LUpdate(dialog->visRgn, list);
  2110.     }
  2111. InsetRect(&itemRect, -1, -1);
  2112. if (!newroms) PenPat(&qd.gray);
  2113. FrameRect(&itemRect);
  2114. if (!newroms) PenPat(&qd.black);
  2115. }
  2116.  
  2117. pascal void misctext(WindowPtr wp, short inum)
  2118. {
  2119. short gtype;
  2120. Handle gitem;
  2121. Rect gbox;
  2122. GrafPort mp;
  2123. GrafPtr gp;
  2124. OSErr rc;
  2125.  
  2126. GetDItem(wp, inum, >ype, &gitem, &gbox);
  2127. rc = dlgnewmap(&mp, &gbox);
  2128. if (rc != 0) return;
  2129. GetPort(&gp);
  2130. SetPort(&mp);
  2131. MoveTo(gbox.left, gbox.top+12);
  2132. switch(inum) {
  2133.     case 13:
  2134.         DrawString("\pBeep Sound:");
  2135.         break;
  2136.     default:
  2137.         break;
  2138.     }
  2139. if (!newroms) {
  2140.     PenPat(&qd.gray);
  2141.     PenMode(patBic);
  2142.     PaintRect(&gbox);
  2143.     }
  2144. SetPort(wp);
  2145. CopyBits(&mp.portBits, &(wp->portBits), &gbox, &gbox, srcCopy, 0L);
  2146. SetPort(gp);
  2147. ClosePort(&mp);
  2148. DisposPtr(dlgmapptr);
  2149. }
  2150.  
  2151. OSErr dlgnewmap(GrafPtr wp, Rect *box)
  2152. {
  2153. BitMap dlgWriteMap;
  2154. Size mapsize;
  2155. GrafPtr gp;
  2156.  
  2157. dlgWriteMap.bounds = *box;
  2158. dlgWriteMap.rowBytes =
  2159.     (dlgWriteMap.bounds.right - dlgWriteMap.bounds.left + 7) >> 3;
  2160. if (dlgWriteMap.rowBytes%2) dlgWriteMap.rowBytes++;
  2161. mapsize = dlgWriteMap.bounds.bottom - dlgWriteMap.bounds.top;
  2162. mapsize = mapsize * dlgWriteMap.rowBytes;
  2163. dlgmapptr = myNewPtr(mapsize, 0);
  2164. if (dlgmapptr == 0L) return(4);
  2165. dlgWriteMap.baseAddr = dlgmapptr;
  2166. wp->portRect = dlgWriteMap.bounds;
  2167. GetPort(&gp);
  2168. OpenPort(wp);
  2169. SetPortBits(&dlgWriteMap);
  2170. EraseRgn(wp->visRgn);
  2171. SetPort(gp);
  2172. }
  2173.  
  2174. void getsndinfo(Handle theResource, short *theID, ResType *theType,
  2175.                 unsigned char *name)
  2176. {
  2177. short i, namelength;
  2178.  
  2179. GetResInfo(theResource, theID, theType, name);
  2180. p2cstr(name);
  2181. namelength = strlen(name);
  2182. if (namelength > 0) {
  2183.     for (i=0; i < namelength; i++) {
  2184.         if (!isspace(name[i])) return;
  2185.         }
  2186.     }
  2187. /* if we get here, the name is null, or all white space */
  2188. /* generate a pseudo-name for the user and "getsndresource" */
  2189. sprintf(name, "(unnamed) #%d", *theID);
  2190. }
  2191.  
  2192. Handle getsndresource(unsigned char *name)
  2193. {
  2194. int resnum;
  2195. Handle result;
  2196.  
  2197. if (strlen(name) > 11) {
  2198.     if (strncmp(name, "(unnamed) #", 11) == 0) {
  2199.         if (1 == sscanf(name+11, "%d", &resnum)) {
  2200.             return(GetResource('snd ', resnum));
  2201.             }
  2202.         }
  2203.     }
  2204. c2pstr(name);
  2205. result = GetNamedResource('snd ', name);
  2206. p2cstr(name);
  2207. return(result);
  2208. }
  2209.  
  2210. void crsetdlg(cnr *cp)
  2211. {
  2212. DialogPtr dlgptr;
  2213. Ptr dStorage;
  2214. WindowPtr behind;
  2215. pascal Boolean (*filterProc) ();
  2216. short * itemHitPtr;
  2217. short itemHit, oldHit;
  2218. short gtype;
  2219. Handle gitem;
  2220. Rect gbox;
  2221. union {
  2222.     OSType type;
  2223.     unsigned char name[4];
  2224.     } cr;
  2225. unsigned char crstr[5];
  2226. unsigned char instr[256];
  2227. char showok;
  2228. OSErr rc;
  2229.  
  2230. dStorage = 0;
  2231. behind = (WindowPtr)-1;
  2232. dlgptr = GetNewDialog(283, dStorage, behind);
  2233. ctrwindow(dlgptr);
  2234.  
  2235. /* copy current value of creator */
  2236. cr.type = cp->cs.text_creator;
  2237. memcpy(crstr+1, cr.name, 4);
  2238. crstr[0] = 4;
  2239.  
  2240. /* define creator text */
  2241. GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  2242. SetIText(gitem, crstr);
  2243. SelIText(dlgptr, 5, 0, 32767);
  2244.  
  2245. /* handle file creator dialog */
  2246. filterProc = DlgFilter;
  2247. itemHitPtr = &itemHit;
  2248.  
  2249. ShowWindow(dlgptr);
  2250.  
  2251. /* frame the default selection */
  2252. framedflt(dlgptr);
  2253.  
  2254. oldHit = 0;
  2255. showok = 1;
  2256. while (1) {
  2257.     /* ModalDialog((ModalFilterProcPtr)filterProc, itemHitPtr); */
  2258.     ModalDialog(filterProc, itemHitPtr);
  2259.     if ((oldHit > 0) && (oldHit != itemHit))
  2260.         switch(oldHit) {
  2261.         case 5:
  2262.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  2263.                 GetIText(gitem, instr);
  2264.                 memcpy(crstr, instr, 5);
  2265.                 if (crstr[0] > 4) crstr[0] = 4;
  2266.                 while (crstr[0] < 4) {
  2267.                     crstr[crstr[0]+1] = ' ';
  2268.                     crstr[0]++;
  2269.                     }
  2270.                 break;
  2271.         default:
  2272.                 break;
  2273.         }
  2274.     oldHit = itemHit;
  2275.     switch(itemHit) {
  2276.         case 1:                                    /* OK */
  2277.                 memcpy(cr.name, crstr+1, 4);
  2278.                 cp->cs.text_creator = cr.type;
  2279.                 break;
  2280.         case 2:                                    /* get from app. */
  2281.                 rc = getapcr(&cr.type);
  2282.                 if (rc != noErr) {
  2283.                     framedflt(dlgptr);
  2284.                     break;
  2285.                     }
  2286.                 if (!showok) {
  2287.                     showok = 1;
  2288.                     GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  2289.                     HiliteControl((ControlHandle)gitem, 0);
  2290.                     }
  2291.                 framedflt(dlgptr);
  2292.                 memcpy(crstr+1, cr.name, 4);
  2293.                 crstr[0] = 4;
  2294.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  2295.                 SetIText(gitem, crstr);
  2296.                 SelIText(dlgptr, 5, 0, 32767);
  2297.                 break;
  2298.         case 5:
  2299.                 GetDItem(dlgptr, 5, >ype, &gitem, &gbox);
  2300.                 GetIText(gitem, instr);
  2301.                 if ((instr[0] < 1) || (instr[0] > 4)) {
  2302.                     if (showok) {
  2303.                         showok = 0;
  2304.                         GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  2305.                         HiliteControl((ControlHandle)gitem, 255);
  2306.                         framedflt(dlgptr);
  2307.                         }
  2308.                     }
  2309.                 else {
  2310.                     if (!showok) {
  2311.                         showok = 1;
  2312.                         GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  2313.                         HiliteControl((ControlHandle)gitem, 0);
  2314.                         framedflt(dlgptr);
  2315.                         }
  2316.                     }
  2317.                 break;
  2318.         default: break;
  2319.         }
  2320.     if ((itemHit == 1) || (itemHit == 3)) break;
  2321.     }
  2322.  
  2323. /* dispose of dialog and return */
  2324. DisposDialog(dlgptr);
  2325. }
  2326.  
  2327. void psdlg(cnr *cp)
  2328. {
  2329. DialogPtr dlgptr;
  2330. Ptr dStorage;
  2331. WindowPtr behind;
  2332. pascal Boolean (*filterProc) ();
  2333. short * itemHitPtr;
  2334. short itemHit;
  2335. short gtype;
  2336. Handle gitem;
  2337. Rect gbox;
  2338. char dlgps;
  2339.  
  2340. dStorage = 0;
  2341. behind = (WindowPtr)-1;
  2342. dlgptr = GetNewDialog(284, dStorage, behind);
  2343. ctrwindow(dlgptr);
  2344.  
  2345. /* copy current value of flag and display it */
  2346. dlgps = cp->cs.simps;
  2347. GetDItem(dlgptr, 3, >ype, &gitem, &gbox);
  2348. SetCtlValue((ControlHandle)gitem, dlgps);
  2349.  
  2350. /* handle PS simulation dialog */
  2351. filterProc = DlgFilter;
  2352. itemHitPtr = &itemHit;
  2353.  
  2354. ShowWindow(dlgptr);
  2355.  
  2356. /* frame the default selection */
  2357. framedflt(dlgptr);
  2358.  
  2359. while (1) {
  2360.     /* ModalDialog((ModalFilterProcPtr)filterProc, itemHitPtr); */
  2361.     ModalDialog(filterProc, itemHitPtr);
  2362.     switch(itemHit) {
  2363.         case 1:                                    /* OK */
  2364.                 cp->cs.simps = dlgps; 
  2365.                 break;
  2366.         case 2:                                    /* Cancel */
  2367.                 break;
  2368.         case 3:                                    /* Check Box */
  2369.         case 4:
  2370.                 dlgps ^= 1;
  2371.                 GetDItem(dlgptr, 3, >ype, &gitem, &gbox);
  2372.                 SetCtlValue((ControlHandle)gitem, dlgps);
  2373.                 break;
  2374.         default: break;
  2375.         }
  2376.     if (itemHit < 3) break;
  2377.     }
  2378.  
  2379. /* dispose of dialog and return */
  2380. DisposDialog(dlgptr);
  2381. }
  2382.  
  2383. void conndlg(cnr *cp)
  2384. {
  2385. DialogPtr dlgptr;
  2386. Ptr dStorage;
  2387. WindowPtr behind;
  2388. pascal Boolean (*filterProc) ();
  2389. short itemHit;
  2390. short gtype;
  2391. Handle gitem;
  2392. Rect gbox;
  2393. unsigned char msgbuff[256];
  2394. unsigned char sname[256];
  2395.  
  2396. dStorage = 0;
  2397. behind = (WindowPtr)-1;
  2398. dlgptr = GetNewDialog(287, dStorage, behind);
  2399. ctrwindow(dlgptr);
  2400.  
  2401. /* set message text */
  2402. get_sessname(sname, cp);
  2403. if (cp->apiopen && (cp->connstate > 3)) {
  2404.     strcpy(msgbuff, "\"");
  2405.     msgappend(msgbuff, 256, sname);
  2406.     msgappend(msgbuff, 256, "\" is a hidden API session connected ");
  2407.     if (cp->connstate == 4) {
  2408.         msgappend(msgbuff, 256, "in line mode.");
  2409.         }
  2410.     else {
  2411.         msgappend(msgbuff, 256, "in 3270 mode.");
  2412.         }
  2413.     }
  2414. else {
  2415.     switch(cp->connstate) {
  2416.         case 0:                    /* should always have a window */
  2417.                     strcpy(msgbuff, "\"");
  2418.                     msgappend(msgbuff, 256, sname);
  2419.                     msgappend(msgbuff, 256, "\" is idle.  Press return to open a new connection.");
  2420.                     break;
  2421.         case 1:                    /* should always have a window */
  2422.                     strcpy(msgbuff, "\"");
  2423.                     msgappend(msgbuff, 256, sname);
  2424.                     msgappend(msgbuff, 256, "\" is an initial serial connection.");
  2425.                     break;
  2426.         case 2:        
  2427.                     strcpy(msgbuff, "Connection pending: awaiting name resolution for \"");
  2428.                     msgappend(msgbuff, 256, cp->hostonly);
  2429.                     msgappend(msgbuff, 256, "\".");
  2430.                     break;
  2431.         case 3:
  2432.                     strcpy(msgbuff, "Connection pending: open in progress to \"");
  2433.                     msgappend(msgbuff, 256, cp->hostonly);
  2434.                     msgappend(msgbuff, 256, "\".");
  2435.                     break;
  2436.         case 4:        /* non-API should always have a window */
  2437.                     strcpy(msgbuff, "\"");
  2438.                     msgappend(msgbuff, 256, sname);
  2439.                     msgappend(msgbuff, 256, "\": connection established in line mode.");
  2440.                     break;
  2441.         case 5:        /* non-API should always have a window */
  2442.                     strcpy(msgbuff, "\"");
  2443.                     msgappend(msgbuff, 256, sname);
  2444.                     msgappend(msgbuff, 256, "\": connection established in 3270 mode.");
  2445.                     break;
  2446.         default:
  2447.                     strcpy(msgbuff, "\"");
  2448.                     msgappend(msgbuff, 256, sname);
  2449.                     msgappend(msgbuff, 256, "\": unknown connection status.");
  2450.                     break;
  2451.         }
  2452.     }
  2453. GetDItem(dlgptr, 3, >ype, &gitem, &gbox);
  2454. c2pstr(msgbuff);
  2455. SetIText(gitem, msgbuff);
  2456.  
  2457. /* handle connection dialog */
  2458. filterProc = DlgFilter;
  2459.  
  2460. ShowWindow(dlgptr);
  2461.  
  2462. /* frame the default selection */
  2463. framedflt(dlgptr);
  2464.  
  2465. /* wait for user to exit */
  2466. ModalDialog(filterProc, &itemHit);
  2467.  
  2468. /* dispose of dialog */
  2469. DisposDialog(dlgptr);
  2470.  
  2471. /* close connection if requested */
  2472. if (itemHit == 2) {
  2473.     if (!(cp->serflg && (cp->connstate <= 1))) {
  2474.         closeresponse(closeUser, cp);
  2475.         }    
  2476.     if (cp->serflg) serlgout(0, cp);
  2477.     else if (cp->tcpflg) tcplgout(0, cp);
  2478.     else salgout(0, cp);
  2479.     }
  2480. }
  2481.  
  2482. void msgappend(unsigned char *buffer, short maxlength, unsigned char *new)
  2483. {
  2484. short currlen, newlen, availlen;
  2485.  
  2486. currlen = strlen(buffer);
  2487. availlen = maxlength - 1 - currlen;
  2488. if (availlen <= 0) return;
  2489. newlen = strlen(new);
  2490. if (newlen > availlen) newlen = availlen;
  2491. memcpy(buffer+currlen, new, newlen); 
  2492. buffer[currlen + newlen] = 0;
  2493. }
  2494.  
  2495. OSErr getapcr(OSType *cr)
  2496. {
  2497. Point where;
  2498. FileFilterProcPtr fileFilter;
  2499. short numTypes;
  2500. SFTypeList typeList;
  2501. DlgHookProcPtr dlgHook;
  2502. SFReply reply;
  2503. FileParam fblk;
  2504. FileParam * _fblk;
  2505. OSErr rc;
  2506.  
  2507. where = sfgpoint;
  2508. fileFilter = 0;
  2509. dlgHook = 0;
  2510. numTypes = 1;
  2511. typeList[0] = 'APPL';
  2512. SFGetFile(where, "\p", fileFilter, numTypes,
  2513.     typeList, dlgHook, &reply);
  2514. if (reply.good == 0) return(1);
  2515.  
  2516. _fblk = &fblk;
  2517. fblk.ioCompletion = 0;
  2518. fblk.ioNamePtr = (StringPtr)&reply.fName;
  2519. fblk.ioVRefNum = reply.vRefNum;
  2520. fblk.ioFVersNum = 0;
  2521. fblk.ioFDirIndex = 0;
  2522. rc = PBGetFInfo((ParmBlkPtr)_fblk, 0);
  2523. if (rc != noErr) return(rc);
  2524. (*cr) = fblk.ioFlFndrInfo.fdCreator;
  2525. return(noErr);
  2526. }
  2527.  
  2528. void cf_featdlg(void)
  2529. {
  2530. DialogPtr dlgptr;
  2531. Ptr dStorage;
  2532. WindowPtr behind;
  2533. pascal Boolean (*filterProc) ();
  2534. short * itemHitPtr;
  2535. short itemHit;
  2536. short dlgnum;
  2537. char newext, newgraphics, newcolor;
  2538. unsigned char cvtstring[256];
  2539. short gtype;
  2540. Handle gitem;
  2541. Rect gbox;
  2542.  
  2543. dStorage = 0;
  2544. behind = (WindowPtr)-1;
  2545. if (colormac) dlgnum = 285;
  2546. else dlgnum = 286;
  2547. dlgptr = GetNewDialog(dlgnum, dStorage, behind);
  2548. ctrwindow(dlgptr);
  2549.  
  2550. /* copy current values of flags and display them */
  2551. newext = cf_ext3270;
  2552. newgraphics = cf_nographics;
  2553. newcolor = cf_nocolor;
  2554. showcffeat(dlgptr, cvtstring, newext, newgraphics, newcolor);
  2555.  
  2556. /* show size for color text bitmap */
  2557. sprintf(cvtstring, "(requires %dK)", cfmapsize(0, newcolor==0));
  2558. c2pstr(cvtstring);
  2559. GetDItem(dlgptr, 8, >ype, &gitem, &gbox);
  2560. SetIText(gitem, cvtstring);
  2561.  
  2562. /* handle  dialog */
  2563. filterProc = DlgFilter;
  2564. itemHitPtr = &itemHit;
  2565.  
  2566. ShowWindow(dlgptr);
  2567.  
  2568. /* frame the default selection */
  2569. framedflt(dlgptr);
  2570.  
  2571. while (1) {
  2572.     ModalDialog(filterProc, itemHitPtr);
  2573.     switch(itemHit) {
  2574.         case 1:                                    /* OK */
  2575.                 cf_ext3270 = newext;
  2576.                 cf_nographics = newgraphics;
  2577.                 cf_nocolor = newcolor;
  2578.                 break;
  2579.         case 2:                                    /* Cancel */
  2580.                 break;
  2581.         case 3:                                    /* Set Defaults */
  2582.                 newext = ds.ext3270;
  2583.                 newgraphics = ds.nographics;
  2584.                 newcolor = ds.nocolor;
  2585.                 break;
  2586.         case 4:                                    /* Extended Datastream */
  2587.                 newext ^= 1;
  2588.                 break;
  2589.         case 5:                                    /* Suppress Graphics */
  2590.         case 6:
  2591.                 newgraphics ^= 1;            
  2592.                 break;
  2593.         case 7:                                    /* No Color */
  2594.         case 8:
  2595.                 newcolor ^= 1;
  2596.                 break;
  2597.         default:
  2598.                 break;
  2599.         }
  2600.     if (itemHit < 3) {
  2601.         break;
  2602.         }
  2603.     else {
  2604.         showcffeat(dlgptr, cvtstring, newext, newgraphics, newcolor);
  2605.         }
  2606.     }
  2607.  
  2608. /* dispose of dialog and return */
  2609. DisposDialog(dlgptr);
  2610. }
  2611.  
  2612. showcffeat(DialogPtr dlgptr, unsigned char *cvs,
  2613.            char ext, char graphics, char color)
  2614. {
  2615. short gtype;
  2616. Handle gitem;
  2617. Rect gbox;
  2618.  
  2619. setit(4, dlgptr, ext);
  2620. setit(5, dlgptr, graphics == 0);
  2621. sprintf(cvs, "(requires %dK)", cfmapsize(1, color==0));
  2622. c2pstr(cvs);
  2623. GetDItem(dlgptr, 6, >ype, &gitem, &gbox);
  2624. SetIText(gitem, cvs);
  2625. if (colormac) {
  2626.     setit(7, dlgptr, color == 0);
  2627.     }
  2628. }
  2629.  
  2630. void setit(short item, DialogPtr dlgptr, short code)
  2631. {
  2632. short gtype;
  2633. Handle gitem;
  2634. Rect gbox;
  2635.  
  2636. GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  2637. SetCtlValue((ControlHandle)gitem, code);
  2638. }
  2639.  
  2640. void setactive(short item, DialogPtr dlgptr, char flag)
  2641. {
  2642. short gtype;
  2643. Handle gitem;
  2644. Rect gbox;
  2645.  
  2646. GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  2647. if (flag) {
  2648.     HiliteControl((ControlHandle)gitem, 0);
  2649.     }
  2650. else {
  2651.     HiliteControl((ControlHandle)gitem, 255);
  2652.     }
  2653. if (item == 1) framedflt(dlgptr);
  2654. }
  2655.  
  2656. short wants_to_quit(cnr *cp)
  2657.             /* if a session is in progress, verify user wants to quit */
  2658. {
  2659. pascal Boolean (*filterProc) ();
  2660. short item;
  2661. unsigned char sname[256];
  2662. unsigned char namebuff[256];
  2663. static char nullstr[1] = {0};
  2664.  
  2665.                     /* return TRUE if no connection established */
  2666. if (cp->connstate == 0) return(1);
  2667.  
  2668. filterProc = DlgFilter;
  2669. arrowcursor();
  2670.  
  2671. get_sessname(sname, cp);
  2672. if (strcmp(cp->sessname, cp->hostonly) == 0) {
  2673.     c2pstr(sname);
  2674.     ParamText(sname, nullstr, nullstr, nullstr);
  2675.     }
  2676. else {
  2677.     strcpy(namebuff, cp->hostonly);
  2678.     if ((strlen(namebuff) + strlen(sname) + 3) < 256) {
  2679.         strcat(namebuff, " (");
  2680.         strcat(namebuff, sname);
  2681.         strcat(namebuff, ")");
  2682.         }
  2683.     c2pstr(namebuff);
  2684.     ParamText(namebuff, nullstr, nullstr, nullstr);
  2685.     }
  2686. item = CautionAlert(279, filterProc);
  2687. ParamText(nullstr, nullstr, nullstr, nullstr);
  2688. if (item == 1) return(0);        /* resume */
  2689. else return(1);                    /* end session */
  2690. }
  2691.  
  2692. void dFullAlt(short kShort, cnr *cp)
  2693. {
  2694. pascal Boolean (*filterProc) ();
  2695. unsigned char buf[10];
  2696. static char nullstr[1] = {0};
  2697.  
  2698. sprintf(buf, "%d", kShort);
  2699.  
  2700. c2pstr(cp->macFName+1);
  2701. c2pstr(buf);
  2702. c2pstr(cp->macVName+1);
  2703. ParamText(cp->macFName+1, buf, cp->macVName+1, nullstr);
  2704. p2cstr(cp->macFName+1);
  2705. p2cstr(buf);
  2706. p2cstr(cp->macVName+1);
  2707. filterProc = DlgFilter;
  2708. arrowcursor();
  2709. StopAlert(265, filterProc);
  2710. ParamText(nullstr, nullstr, nullstr, nullstr);
  2711. }
  2712.  
  2713. void settext(DialogPtr dlgptr, short item, unsigned char *text)
  2714. {
  2715.     short gtype;
  2716.     Handle gitem;
  2717.     Rect gbox;
  2718.  
  2719.     GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  2720.     c2pstr(text);
  2721.     SetIText(gitem, text);
  2722.     p2cstr(text);
  2723. }
  2724.  
  2725. void ctrwindow(GrafPtr wp)
  2726. {
  2727. short scrhsize, scrvsize;
  2728. short whsize, wvsize;
  2729.  
  2730. scrhsize = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
  2731. scrvsize = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
  2732. whsize = wp->portRect.right-wp->portRect.left;
  2733. wvsize = wp->portRect.bottom - wp->portRect.top;
  2734. MoveWindow(wp, (scrhsize-whsize)/2, (scrvsize-wvsize)/3, 0);
  2735. }
  2736.  
  2737. void ctralrt(short a)
  2738. {                /* alert number */
  2739. Handle reshnd;
  2740. struct Rect * rptr;
  2741. short scrhsize, scrvsize;
  2742. short ahsize, avsize;
  2743.  
  2744. CouldAlert(a);        /* read alert into memory and make unpurgeable */
  2745. reshnd = GetResource('ALRT', a);
  2746. if (reshnd == 0) return;
  2747. rptr = (struct Rect *)*reshnd;
  2748. scrhsize = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
  2749. scrvsize = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
  2750. ahsize = rptr->right - rptr->left;
  2751. avsize = rptr->bottom - rptr->top;
  2752. rptr->top = (scrvsize-avsize)/3;
  2753. rptr->left = (scrhsize-ahsize)/2;
  2754. rptr->bottom = rptr->top + avsize;
  2755. rptr->right = rptr->left + ahsize;
  2756. }
  2757.  
  2758. void framedflt(DialogPtr dlgptr)
  2759. {
  2760. short gtype;
  2761. Handle gitem;
  2762. Rect gbox;
  2763. GrafPtr gp;
  2764.  
  2765. GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  2766. GetPort(&gp);
  2767. SetPort(dlgptr);
  2768. OutlineButton((ControlHandle)gitem);
  2769. SetPort(gp);
  2770. }
  2771.  
  2772. void OutlineButton(ControlHandle button)
  2773. {
  2774. /* This routine provided by Macintosh DTS: */
  2775.  
  2776. /*    Given any control handle, this will draw an outline around it.  This is
  2777.     used for the default button of a window.  The extra nice feature here is
  2778.     that I'll erase the outline for buttons that are inactive.  Seems like
  2779.     there should be a Toolbox call for getting a control's hilite state.
  2780.     Since there isn't, I have to look into the control record myself.    This
  2781.     should be called for update and activate events.
  2782.  
  2783.     The method for determining the oval diameters for the roundrect is a
  2784.     little different than that recommended by Inside Mac.    IM I-407 suggests
  2785.     that you use a hardcoded (16,16) for the diameters. However, this only
  2786.     looks good for small roundrects. For larger ones, the outline doesn't
  2787.     follow the inner roundrect because the CDEF for simply buttons doesn't
  2788.     use (16,16). Instead, it uses half the height of the button as the
  2789.     diameter. By using this formula, too, our outlines look better.            */
  2790.  
  2791. /*    WARNING: This will set the current port to the control's window.        */
  2792.  
  2793. Rect theRect;
  2794. PenState curPen;
  2795. short buttonOval;
  2796.         
  2797. if (button != 0) {
  2798.     /* SetPort((*button)->contrlOwner); */ /* done by caller */
  2799.     GetPenState(&curPen);
  2800.     PenNormal();
  2801.     theRect = (*button)->contrlRect;
  2802.     InsetRect(&theRect, kButtonFrameInset, kButtonFrameInset);
  2803.     buttonOval = (theRect.bottom - theRect.top) / 2;
  2804.     if ((*button)->contrlHilite == 0) {
  2805.         PenPat(&qd.black);
  2806.         }
  2807.     else {
  2808.         PenPat(&qd.gray);
  2809.         }
  2810.     PenSize(kButtonFrameSize, kButtonFrameSize);
  2811.     FrameRoundRect(&theRect, buttonOval, buttonOval);
  2812.     SetPenState(&curPen);
  2813.     }
  2814. }
  2815.  
  2816. void arrowcursor(void)
  2817. {
  2818. if (!dfltcurs) {
  2819.     dfltcurs = 1;
  2820.     SetCursor(normcurs);
  2821.     }
  2822. }